2014-12-12 19:49:58 +01:00
|
|
|
import copy
|
|
|
|
|
2014-12-12 21:11:22 +01:00
|
|
|
class Logique:
|
|
|
|
"""
|
|
|
|
Logique des jeux sur damier
|
|
|
|
"""
|
|
|
|
|
2014-12-14 00:47:49 +01:00
|
|
|
PCE_VIDE = 0 # Valeur à mettre sur la grille quand il n'y a pas de pièce
|
|
|
|
BLANC = True # Valeur correspondant au joueur blanc
|
|
|
|
NOIR = False # Valeur correspondant au joueur noir
|
2014-12-12 21:11:22 +01:00
|
|
|
|
|
|
|
@staticmethod
|
2014-12-14 00:47:49 +01:00
|
|
|
def eCaseBlanche(x, y):
|
|
|
|
"""
|
|
|
|
Indique si la case aux coordonnées indiquée est blanche.
|
|
|
|
"""
|
|
|
|
return x % 2 == y % 2
|
2014-12-12 21:11:22 +01:00
|
|
|
|
|
|
|
def cGrille(self):
|
2014-12-14 00:47:49 +01:00
|
|
|
"""
|
|
|
|
Crée le tableau self.grille.
|
|
|
|
"""
|
|
|
|
for x in range(self.CASES_COTE): # TODO Peut être amélioré
|
2014-12-12 21:11:22 +01:00
|
|
|
colonne = []
|
|
|
|
for y in range(self.CASES_COTE):
|
|
|
|
colonne.append(self.PCE_VIDE)
|
|
|
|
self.grille.append(colonne)
|
|
|
|
|
2014-12-14 16:43:11 +01:00
|
|
|
def ePieceBlanc(self, piece):
|
2014-12-14 00:47:49 +01:00
|
|
|
"""
|
|
|
|
Indique si la pièce est une pièce blanche.
|
|
|
|
"""
|
2014-12-14 16:43:11 +01:00
|
|
|
return piece in self.BLANCS
|
2014-12-12 21:11:22 +01:00
|
|
|
|
2014-12-14 16:43:11 +01:00
|
|
|
def ePieceNoir(self, piece):
|
2014-12-14 00:47:49 +01:00
|
|
|
"""
|
|
|
|
Indique si la pièce est une pièce noire.
|
|
|
|
"""
|
2014-12-14 16:43:11 +01:00
|
|
|
return piece in self.NOIRS
|
2014-12-12 21:11:22 +01:00
|
|
|
|
|
|
|
def ePiece(self, piece):
|
2014-12-14 00:47:49 +01:00
|
|
|
"""
|
|
|
|
Indique si la pièce est une pièce.
|
|
|
|
"""
|
2014-12-12 21:11:22 +01:00
|
|
|
# return piece != self.PCE_VIDE
|
2014-12-14 16:43:11 +01:00
|
|
|
return self.ePieceBlanc(piece) or self.ePieceNoir(piece)
|
2014-12-12 21:11:22 +01:00
|
|
|
|
|
|
|
def tPiece(self, piece):
|
2014-12-14 00:47:49 +01:00
|
|
|
"""
|
|
|
|
Retourne le type de pièce de la pièce donnée.
|
|
|
|
"""
|
2014-12-14 16:43:11 +01:00
|
|
|
if self.ePieceBlanc(piece):
|
2014-12-12 21:11:22 +01:00
|
|
|
return piece - self.DECALAGE_BLANCS
|
2014-12-14 16:43:11 +01:00
|
|
|
elif self.ePieceNoir(piece):
|
2014-12-12 21:11:22 +01:00
|
|
|
return piece - self.DECALAGE_NOIRS
|
|
|
|
else:
|
|
|
|
return self.PCE_VIDE
|
|
|
|
|
2014-12-14 16:43:11 +01:00
|
|
|
def aSonTour(self, piece):
|
2014-12-14 00:47:49 +01:00
|
|
|
"""
|
|
|
|
Indique si la pièce donnée a le droit de jouer.
|
|
|
|
"""
|
2014-12-14 16:43:11 +01:00
|
|
|
return (self.ePieceNoir(piece) and self.joueur == self.NOIR) or \
|
|
|
|
(self.ePieceBlanc(piece) and self.joueur == self.BLANC)
|
2014-12-12 21:11:22 +01:00
|
|
|
|
|
|
|
|
|
|
|
class LogiqueEchecs(Logique):
|
|
|
|
"""
|
|
|
|
Logique du jeu d'Échecs
|
|
|
|
"""
|
2014-12-12 19:49:58 +01:00
|
|
|
|
2014-12-14 00:47:49 +01:00
|
|
|
CASES_COTE = 8 # Cases de coté
|
2014-12-12 19:49:58 +01:00
|
|
|
|
2014-12-14 00:47:49 +01:00
|
|
|
# Type de pièces
|
2014-12-12 21:11:22 +01:00
|
|
|
PCE_PION = 1
|
|
|
|
PCE_TOUR = 2
|
|
|
|
PCE_CAVALIER = 3
|
|
|
|
PCE_FOU = 4
|
|
|
|
PCE_DAME = 5
|
|
|
|
PCE_ROI = 6
|
|
|
|
|
2014-12-14 00:47:49 +01:00
|
|
|
DECALAGE_BLANCS = 0 # Valeur à partir de laquelle sont compris les pièces blanches
|
|
|
|
DECALAGE_NOIRS = 10 # Valeur à partir de laquelle sont compris les pièces noires
|
2014-12-12 21:11:22 +01:00
|
|
|
|
2014-12-14 00:47:49 +01:00
|
|
|
BLANCS = range(DECALAGE_BLANCS+PCE_PION, DECALAGE_BLANCS+PCE_ROI+1) # Intervalle contenant les pièces blancs
|
|
|
|
NOIRS = range(DECALAGE_NOIRS+PCE_PION, DECALAGE_NOIRS+PCE_ROI+1) # Intervalle contenant les pièces noirs
|
2014-12-12 21:11:22 +01:00
|
|
|
|
|
|
|
|
2014-12-14 00:47:49 +01:00
|
|
|
# Codes d'erreur de mouvement
|
2014-12-12 19:49:58 +01:00
|
|
|
MVT_INCONNU = 'Cause inconnue'
|
|
|
|
MVT_OK = 'Valide'
|
|
|
|
MVT_ROQUE = 'Roque'
|
|
|
|
MVT_SELECTION = 'Mauvais tour'
|
|
|
|
MVT_SUR_PLACE = 'Immobile'
|
|
|
|
MVT_SAUT_AMI = 'Saut ami'
|
2014-12-14 16:43:11 +01:00
|
|
|
MVT_PIECE_INC = 'Pièce inconnu'
|
2014-12-12 19:49:58 +01:00
|
|
|
MVT_N_AUTORISE = 'Non-autorisé'
|
2014-12-14 16:43:11 +01:00
|
|
|
MVT_OBSTRUCTION = 'Pièce en chemin'
|
2014-12-12 19:49:58 +01:00
|
|
|
MVT_ECHEC = 'Échec au roi'
|
|
|
|
|
|
|
|
def __init__(self):
|
2014-12-14 00:47:49 +01:00
|
|
|
"""
|
|
|
|
Constructeur de LogiqueEchecs
|
|
|
|
"""
|
|
|
|
self.grille = [] # Grille de jeu
|
2014-12-12 19:49:58 +01:00
|
|
|
self.cGrille()
|
|
|
|
self.remplirGrille()
|
2014-12-14 00:47:49 +01:00
|
|
|
self.joueur = self.BLANC # Premier joueur
|
2014-12-12 19:49:58 +01:00
|
|
|
self.partieFinie = False
|
|
|
|
self.victorieux = None
|
|
|
|
|
|
|
|
def remplirGrille(self):
|
2014-12-14 00:47:49 +01:00
|
|
|
"""
|
|
|
|
Remplis la grille avec les pièces nécessaire à une nouvelle partie.
|
|
|
|
"""
|
2014-12-12 21:11:22 +01:00
|
|
|
speciales = [self.PCE_TOUR, self.PCE_CAVALIER, self.PCE_FOU, self.PCE_ROI, self.PCE_DAME]
|
2014-12-13 23:04:54 +01:00
|
|
|
speciales += speciales[2::-1]
|
2014-12-12 19:49:58 +01:00
|
|
|
for i in range(0, 8):
|
2014-12-12 21:11:22 +01:00
|
|
|
self.grille[i][0] = self.DECALAGE_NOIRS + speciales[i]
|
|
|
|
self.grille[i][1] = self.DECALAGE_NOIRS + self.PCE_PION
|
|
|
|
self.grille[i][6] = self.DECALAGE_BLANCS + self.PCE_PION
|
|
|
|
self.grille[i][7] = self.DECALAGE_BLANCS + speciales[i]
|
2014-12-12 19:49:58 +01:00
|
|
|
|
2014-12-14 16:43:11 +01:00
|
|
|
def deplPossiblePion(self, x1, y1, x2, y2):
|
2014-12-14 00:47:49 +01:00
|
|
|
"""
|
|
|
|
Vérifie si le déplacement est possible pour un pion.
|
|
|
|
"""
|
2014-12-12 19:49:58 +01:00
|
|
|
if x1 == x2 and self.grille[x2][y2] <= 0: # Avance
|
|
|
|
if self.joueur:
|
|
|
|
if y2 == y1 - 1:
|
2014-12-12 21:11:22 +01:00
|
|
|
return self.MVT_OK
|
2014-12-12 19:49:58 +01:00
|
|
|
elif y1 == 6 and y2 == 4 and self.grille[x1][5] == 0:
|
2014-12-12 21:11:22 +01:00
|
|
|
return self.MVT_OK
|
2014-12-12 19:49:58 +01:00
|
|
|
else:
|
2014-12-12 21:11:22 +01:00
|
|
|
return self.MVT_N_AUTORISE
|
2014-12-12 19:49:58 +01:00
|
|
|
else:
|
|
|
|
if y2 == y1 + 1:
|
2014-12-12 21:11:22 +01:00
|
|
|
return self.MVT_OK
|
2014-12-12 19:49:58 +01:00
|
|
|
elif y1 == 1 and y2 == 3 and self.grille[x1][2] == 0:
|
2014-12-12 21:11:22 +01:00
|
|
|
return self.MVT_OK
|
2014-12-12 19:49:58 +01:00
|
|
|
else:
|
2014-12-12 21:11:22 +01:00
|
|
|
return self.MVT_N_AUTORISE
|
2014-12-12 19:49:58 +01:00
|
|
|
elif abs(x1-x2) == 1: # Saut
|
|
|
|
if self.joueur:
|
|
|
|
if y2 == y1 - 1 and \
|
2014-12-14 16:43:11 +01:00
|
|
|
self.ePieceNoir(self.grille[x2][y2]):
|
2014-12-12 21:11:22 +01:00
|
|
|
return self.MVT_OK
|
2014-12-12 19:49:58 +01:00
|
|
|
else:
|
2014-12-12 21:11:22 +01:00
|
|
|
return self.MVT_N_AUTORISE
|
2014-12-12 19:49:58 +01:00
|
|
|
else:
|
|
|
|
if y2 == y1 + 1 and \
|
2014-12-14 16:43:11 +01:00
|
|
|
self.ePieceBlanc(self.grille[x2][y2]):
|
2014-12-12 21:11:22 +01:00
|
|
|
return self.MVT_OK
|
2014-12-12 19:49:58 +01:00
|
|
|
else:
|
2014-12-12 21:11:22 +01:00
|
|
|
return self.MVT_N_AUTORISE
|
2014-12-12 19:49:58 +01:00
|
|
|
else:
|
2014-12-12 21:11:22 +01:00
|
|
|
return self.MVT_N_AUTORISE
|
2014-12-12 19:49:58 +01:00
|
|
|
|
2014-12-14 16:43:11 +01:00
|
|
|
def deplPossibleTour(self, x1, y1, x2, y2):
|
2014-12-14 00:47:49 +01:00
|
|
|
"""
|
|
|
|
Vérifie si le déplacement est possible pour une tour.
|
|
|
|
"""
|
2014-12-12 19:49:58 +01:00
|
|
|
if y1 == y2:
|
|
|
|
sens = (x2-x1)//abs(x2-x1)
|
|
|
|
for x in range(x1+sens, x2, sens):
|
2014-12-12 21:11:22 +01:00
|
|
|
if self.ePiece(self.grille[x][y1]):
|
|
|
|
return self.MVT_OBSTRUCTION
|
2014-12-12 19:49:58 +01:00
|
|
|
elif x1 == x2:
|
|
|
|
sens = (y2-y1)//abs(y2-y1)
|
|
|
|
for y in range(y1+sens, y2, sens):
|
2014-12-12 21:11:22 +01:00
|
|
|
if self.ePiece(self.grille[x1][y]):
|
|
|
|
return self.MVT_OBSTRUCTION
|
2014-12-12 19:49:58 +01:00
|
|
|
else:
|
2014-12-12 21:11:22 +01:00
|
|
|
return self.MVT_N_AUTORISE
|
|
|
|
return self.MVT_OK
|
2014-12-12 19:49:58 +01:00
|
|
|
|
2014-12-14 16:43:11 +01:00
|
|
|
def deplPossibleFou(self, x1, y1, x2, y2):
|
2014-12-14 00:47:49 +01:00
|
|
|
"""
|
|
|
|
Vérifie si le déplacement est possible pour un fou.
|
|
|
|
"""
|
2014-12-12 19:49:58 +01:00
|
|
|
if abs(x2-x1) == abs(y2-y1):
|
|
|
|
sensX = (x2-x1)//abs(x2-x1)
|
|
|
|
sensY = (y2-y1)//abs(y2-y1)
|
|
|
|
x = x1
|
|
|
|
y = y1
|
|
|
|
dist = 0
|
|
|
|
distTot = abs(x2-x1)
|
|
|
|
while dist < distTot:
|
|
|
|
dist += 1
|
|
|
|
x += sensX
|
|
|
|
y += sensY
|
2014-12-12 21:11:22 +01:00
|
|
|
if self.ePiece(self.grille[x][y]):
|
2014-12-12 19:49:58 +01:00
|
|
|
if dist == distTot:
|
2014-12-12 21:11:22 +01:00
|
|
|
return self.MVT_OK # Saut
|
2014-12-12 19:49:58 +01:00
|
|
|
else:
|
2014-12-12 21:11:22 +01:00
|
|
|
return self.MVT_OBSTRUCTION
|
|
|
|
return self.MVT_OK # Vide
|
2014-12-12 19:49:58 +01:00
|
|
|
else:
|
2014-12-12 21:11:22 +01:00
|
|
|
return self.MVT_N_AUTORISE
|
2014-12-12 19:49:58 +01:00
|
|
|
|
2014-12-14 16:43:11 +01:00
|
|
|
def deplPossibleCavalier(self, x1, y1, x2, y2):
|
2014-12-14 00:47:49 +01:00
|
|
|
"""
|
|
|
|
Vérifie si le déplacement est possible pour un cavalier.
|
|
|
|
"""
|
2014-12-12 19:49:58 +01:00
|
|
|
if (abs(x2-x1) == 2 and abs(y2-y1) == 1) or (abs(y2-y1) == 2 and abs(x2-x1) == 1):
|
2014-12-12 21:11:22 +01:00
|
|
|
return self.MVT_OK
|
2014-12-12 19:49:58 +01:00
|
|
|
else:
|
2014-12-12 21:11:22 +01:00
|
|
|
return self.MVT_N_AUTORISE
|
2014-12-12 19:49:58 +01:00
|
|
|
|
2014-12-14 16:43:11 +01:00
|
|
|
def deplPossible(self, x1, y1, x2, y2): # TODO Utiliser la gestion d'erreurs ?
|
2014-12-14 00:47:49 +01:00
|
|
|
"""
|
|
|
|
Vérifie si le déplacement est possible.
|
|
|
|
"""
|
2014-12-14 16:43:11 +01:00
|
|
|
piece = self.grille[x1][y1]
|
|
|
|
if self.aSonTour(piece):
|
2014-12-12 19:49:58 +01:00
|
|
|
if (x1 != x2 or y1 != y2):
|
|
|
|
if not self.aSonTour(self.grille[x2][y2]):
|
2014-12-14 16:43:11 +01:00
|
|
|
tPiece = self.tPiece(piece)
|
|
|
|
if tPiece == self.PCE_PION: # Pion
|
|
|
|
return self.deplPossiblePion(x1, y1, x2, y2)
|
|
|
|
elif tPiece == self.PCE_TOUR: # Tour
|
|
|
|
return self.deplPossibleTour(x1, y1, x2, y2)
|
|
|
|
elif tPiece == self.PCE_CAVALIER:
|
|
|
|
return self.deplPossibleCavalier(x1, y1, x2, y2)
|
|
|
|
elif tPiece == self.PCE_FOU:
|
|
|
|
return self.deplPossibleFou(x1, y1, x2, y2)
|
|
|
|
elif tPiece == self.PCE_DAME:
|
|
|
|
tour = self.deplPossibleTour(x1, y1, x2, y2)
|
|
|
|
fou = self.deplPossibleFou(x1, y1, x2, y2)
|
2014-12-12 21:11:22 +01:00
|
|
|
if tour == self.MVT_OK or fou == self.MVT_OK:
|
|
|
|
return self.MVT_OK
|
|
|
|
elif tour == self.MVT_OBSTRUCTION or fou == self.MVT_OBSTRUCTION:
|
|
|
|
return self.MVT_OBSTRUCTION
|
2014-12-12 19:49:58 +01:00
|
|
|
else:
|
2014-12-12 21:11:22 +01:00
|
|
|
return self.MVT_N_AUTORISE
|
2014-12-14 16:43:11 +01:00
|
|
|
elif tPiece == self.PCE_ROI:
|
2014-12-12 19:49:58 +01:00
|
|
|
if abs(x2-x1) <= 1 and abs(y2-y1) <= 1:
|
2014-12-12 21:11:22 +01:00
|
|
|
return self.MVT_OK
|
2014-12-12 19:49:58 +01:00
|
|
|
else:
|
2014-12-12 21:11:22 +01:00
|
|
|
return self.MVT_N_AUTORISE
|
2014-12-12 19:49:58 +01:00
|
|
|
else:
|
2014-12-14 16:43:11 +01:00
|
|
|
return self.MVT_PIECE_INC
|
2014-12-12 19:49:58 +01:00
|
|
|
else:
|
2014-12-12 21:11:22 +01:00
|
|
|
return self.MVT_SAUT_AMI
|
2014-12-12 19:49:58 +01:00
|
|
|
else:
|
2014-12-12 21:11:22 +01:00
|
|
|
return self.MVT_SUR_PLACE
|
2014-12-12 19:49:58 +01:00
|
|
|
else:
|
2014-12-12 21:11:22 +01:00
|
|
|
return self.MVT_SELECTION
|
|
|
|
return self.MVT_INCONNU
|
2014-12-12 19:49:58 +01:00
|
|
|
|
|
|
|
def mvtPossible(self, x1, y1, x2, y2):
|
2014-12-14 00:47:49 +01:00
|
|
|
"""
|
|
|
|
Vérifie si le mouvement est possible.
|
|
|
|
Contrairement aux fonctions de vérification de déplacement, celle-ci
|
|
|
|
vérifie si le mouvement est réalisable si le roi est en échec.
|
|
|
|
"""
|
2014-12-14 16:43:11 +01:00
|
|
|
test = self.deplPossible(x1, y1, x2, y2)
|
2014-12-12 21:11:22 +01:00
|
|
|
if test == self.MVT_OK:
|
2014-12-12 19:49:58 +01:00
|
|
|
# On copie la partie actuelle pour tester le mouvement et vérifier l'échec
|
|
|
|
copie = copy.deepcopy(self);
|
2014-12-14 16:43:11 +01:00
|
|
|
copie.dPieceSansEchec(x1, y1, x2, y2)
|
2014-12-12 19:49:58 +01:00
|
|
|
mvtsPossiblesTousAdverses = []
|
2014-12-14 00:47:49 +01:00
|
|
|
# On cherche la position du roi
|
2014-12-14 16:43:11 +01:00
|
|
|
pieceRoi = self.PCE_ROI + self.DECALAGE_BLANCS if self.joueur else self.DECALAGE_NOIRS
|
2014-12-12 19:49:58 +01:00
|
|
|
roi = [-1, -1]
|
2014-12-12 21:11:22 +01:00
|
|
|
for x in range(0, self.CASES_COTE):
|
|
|
|
for y in range(0, self.CASES_COTE):
|
2014-12-12 19:49:58 +01:00
|
|
|
mvtsPossiblesTousAdverses += copie.mvtsPossiblesSansEchec(x, y)
|
2014-12-14 16:43:11 +01:00
|
|
|
if copie.grille[x][y] == pieceRoi:
|
2014-12-12 19:49:58 +01:00
|
|
|
roi = [x, y]
|
2014-12-14 00:47:49 +01:00
|
|
|
if roi in mvtsPossiblesTousAdverses: # Si le roi peut être sauté au tour adverse
|
2014-12-12 21:11:22 +01:00
|
|
|
return self.MVT_ECHEC
|
2014-12-12 19:49:58 +01:00
|
|
|
else:
|
|
|
|
return test
|
|
|
|
else:
|
|
|
|
return test
|
|
|
|
|
|
|
|
def mvtsPossiblesSansEchec(self, x1, y1):
|
2014-12-14 00:47:49 +01:00
|
|
|
"""
|
|
|
|
Donne la liste des déplacements possible pour la pièce donnée.
|
|
|
|
"""
|
2014-12-12 19:49:58 +01:00
|
|
|
tableau = []
|
2014-12-12 21:11:22 +01:00
|
|
|
for x2 in range(0, self.CASES_COTE):
|
|
|
|
for y2 in range(0, self.CASES_COTE):
|
2014-12-14 16:43:11 +01:00
|
|
|
if self.deplPossible(x1, y1, x2, y2) == self.MVT_OK:
|
2014-12-12 19:49:58 +01:00
|
|
|
tableau.append([x2, y2])
|
|
|
|
return tableau
|
|
|
|
|
|
|
|
def mvtsPossibles(self, x1, y1):
|
2014-12-14 00:47:49 +01:00
|
|
|
"""
|
|
|
|
Donne la liste des mouvements possible pour la pièce donnée.
|
|
|
|
"""
|
2014-12-12 19:49:58 +01:00
|
|
|
tableau = []
|
2014-12-12 21:11:22 +01:00
|
|
|
for x2 in range(0, self.CASES_COTE):
|
|
|
|
for y2 in range(0, self.CASES_COTE):
|
|
|
|
if self.mvtPossible(x1, y1, x2, y2) == self.MVT_OK:
|
2014-12-12 19:49:58 +01:00
|
|
|
tableau.append([x2, y2])
|
|
|
|
return tableau
|
|
|
|
|
2014-12-14 16:43:11 +01:00
|
|
|
def dPieceSansEchec(self, x1, y1, x2, y2):
|
2014-12-14 00:47:49 +01:00
|
|
|
"""
|
2014-12-14 16:43:11 +01:00
|
|
|
Déplace la pièce aux coordonnées 1 données aux coordonnées 2 données.
|
2014-12-14 00:47:49 +01:00
|
|
|
Ne vérifie pas si le mouvement peut conduire à une prise illégale du roi.
|
|
|
|
(Est utilisé dans pour cette détection)
|
|
|
|
"""
|
2014-12-14 16:43:11 +01:00
|
|
|
test = self.deplPossible(x1, y1, x2, y2)
|
2014-12-12 21:11:22 +01:00
|
|
|
if test == self.MVT_OK:
|
|
|
|
self.grille[x1][y1], self.grille[x2][y2] = self.PCE_VIDE, self.grille[x1][y1]
|
2014-12-12 19:49:58 +01:00
|
|
|
self.joueur = not self.joueur
|
|
|
|
|
|
|
|
def vEchecMat(self):
|
|
|
|
"""
|
2014-12-14 00:47:49 +01:00
|
|
|
Vérifie si le joueur actuel est en échec et mat et déclenche
|
|
|
|
éventuellement la victoire
|
|
|
|
(Le "pat" est considiéré comme une victoire)
|
2014-12-12 19:49:58 +01:00
|
|
|
"""
|
2014-12-14 00:47:49 +01:00
|
|
|
# Vérifications si aucun mouvement pour aucune pièce n'est possible
|
2014-12-12 21:11:22 +01:00
|
|
|
for x in range(0, self.CASES_COTE):
|
|
|
|
for y in range(0, self.CASES_COTE):
|
2014-12-12 19:49:58 +01:00
|
|
|
if len(self.mvtsPossibles(x, y)) > 0:
|
|
|
|
return False
|
|
|
|
self.partieFinie = True
|
|
|
|
self.victorieux = not self.joueur
|
|
|
|
return True
|
|
|
|
|
2014-12-14 16:43:11 +01:00
|
|
|
def dPiece(self, x1, y1, x2, y2):
|
2014-12-14 00:47:49 +01:00
|
|
|
"""
|
2014-12-14 16:43:11 +01:00
|
|
|
Déplace la pièce aux coordonnées 1 données aux coordonnées 2 données.
|
2014-12-14 00:47:49 +01:00
|
|
|
Renvoie les détails du mouvement.
|
|
|
|
"""
|
2014-12-12 19:49:58 +01:00
|
|
|
test = self.mvtPossible(x1, y1, x2, y2)
|
|
|
|
retour = {
|
|
|
|
'valide': False,
|
|
|
|
'message': test,
|
2014-12-14 16:43:11 +01:00
|
|
|
'deplacer': [], # Pièces à déplacer
|
|
|
|
'supprimer': [], # Pièces à supprimer
|
2014-12-12 19:49:58 +01:00
|
|
|
}
|
2014-12-12 21:11:22 +01:00
|
|
|
if test == self.MVT_OK:
|
2014-12-12 19:49:58 +01:00
|
|
|
retour['valide'] = True
|
2014-12-12 21:11:22 +01:00
|
|
|
if self.ePiece(self.grille[x2][y2]):
|
2014-12-12 19:49:58 +01:00
|
|
|
retour['supprimer'].append([x2, y2])
|
|
|
|
retour['deplacer'].append([x1, y1, x2, y2])
|
2014-12-12 21:11:22 +01:00
|
|
|
self.grille[x1][y1], self.grille[x2][y2] = self.PCE_VIDE, self.grille[x1][y1]
|
2014-12-12 19:49:58 +01:00
|
|
|
self.joueur = not self.joueur
|
|
|
|
self.vEchecMat()
|
2014-12-13 23:04:54 +01:00
|
|
|
return retour
|