251 lines
9.2 KiB
Python
251 lines
9.2 KiB
Python
import copy
|
|
|
|
class LogiqueEchecs:
|
|
|
|
CASES_COTE = 8
|
|
|
|
MVT_INCONNU = 'Cause inconnue'
|
|
MVT_OK = 'Valide'
|
|
MVT_ROQUE = 'Roque'
|
|
MVT_SELECTION = 'Mauvais tour'
|
|
MVT_SUR_PLACE = 'Immobile'
|
|
MVT_SAUT_AMI = 'Saut ami'
|
|
MVT_PION_INC = 'Pion inconnu'
|
|
MVT_N_AUTORISE = 'Non-autorisé'
|
|
MVT_OBSTRUCTION = 'Pion en chemin'
|
|
MVT_ECHEC = 'Échec au roi'
|
|
|
|
def __init__(self):
|
|
|
|
self.grille = []
|
|
self.cGrille()
|
|
self.remplirGrille()
|
|
self.joueur = True
|
|
self.partieFinie = False
|
|
self.victorieux = None
|
|
|
|
@staticmethod
|
|
def eNoir(xD, yD):
|
|
return xD % 2 != yD % 2
|
|
|
|
def cGrille(self):
|
|
for x in range(LogiqueEchecs.CASES_COTE):
|
|
colonne = []
|
|
for y in range(LogiqueEchecs.CASES_COTE):
|
|
colonne.append(0)
|
|
self.grille.append(colonne)
|
|
|
|
def remplirGrille(self):
|
|
speciales = [2, 3, 4, 6, 5, 4, 3, 2]
|
|
for i in range(0, 8):
|
|
self.grille[i][0] = speciales[i] + 10
|
|
self.grille[i][1] = 11
|
|
self.grille[i][6] = 1
|
|
self.grille[i][7] = speciales[i]
|
|
|
|
def cPion(self, x, y, piece):
|
|
"""
|
|
"""
|
|
self.grille[x][y] = piece
|
|
return True
|
|
|
|
@staticmethod
|
|
def ePionBlanc(pion):
|
|
return pion in range(1, 7)
|
|
|
|
@staticmethod
|
|
def ePionNoir(pion):
|
|
return pion in range(11, 17)
|
|
|
|
|
|
def aSonTour(self, pion):
|
|
return (self.ePionNoir(pion) and self.joueur == False) or \
|
|
(self.ePionBlanc(pion) and self.joueur == True)
|
|
|
|
def mvtPossibleSansEchecPion(self, x1, y1, x2, y2):
|
|
if x1 == x2 and self.grille[x2][y2] <= 0: # Avance
|
|
if self.joueur:
|
|
if y2 == y1 - 1:
|
|
return LogiqueEchecs.MVT_OK
|
|
elif y1 == 6 and y2 == 4 and self.grille[x1][5] == 0:
|
|
return LogiqueEchecs.MVT_OK
|
|
else:
|
|
return LogiqueEchecs.MVT_N_AUTORISE
|
|
else:
|
|
if y2 == y1 + 1:
|
|
return LogiqueEchecs.MVT_OK
|
|
elif y1 == 1 and y2 == 3 and self.grille[x1][2] == 0:
|
|
return LogiqueEchecs.MVT_OK
|
|
else:
|
|
return LogiqueEchecs.MVT_N_AUTORISE
|
|
elif abs(x1-x2) == 1: # Saut
|
|
if self.joueur:
|
|
if y2 == y1 - 1 and \
|
|
self.ePionNoir(self.grille[x2][y2]):
|
|
return LogiqueEchecs.MVT_OK
|
|
else:
|
|
return LogiqueEchecs.MVT_N_AUTORISE
|
|
else:
|
|
if y2 == y1 + 1 and \
|
|
self.ePionBlanc(self.grille[x2][y2]):
|
|
return LogiqueEchecs.MVT_OK
|
|
else:
|
|
return LogiqueEchecs.MVT_N_AUTORISE
|
|
else:
|
|
return LogiqueEchecs.MVT_N_AUTORISE
|
|
|
|
def mvtPossibleSansEchecTour(self, x1, y1, x2, y2):
|
|
if y1 == y2:
|
|
sens = (x2-x1)//abs(x2-x1)
|
|
for x in range(x1+sens, x2, sens):
|
|
if self.grille[x][y1] > 0:
|
|
return LogiqueEchecs.MVT_OBSTRUCTION
|
|
elif x1 == x2:
|
|
sens = (y2-y1)//abs(y2-y1)
|
|
for y in range(y1+sens, y2, sens):
|
|
if self.grille[x1][y] > 0:
|
|
return LogiqueEchecs.MVT_OBSTRUCTION
|
|
else:
|
|
return LogiqueEchecs.MVT_N_AUTORISE
|
|
return LogiqueEchecs.MVT_OK
|
|
|
|
def mvtPossibleSansEchecFou(self, x1, y1, x2, y2):
|
|
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
|
|
if self.grille[x][y] > 0:
|
|
if dist == distTot:
|
|
return LogiqueEchecs.MVT_OK # Saut
|
|
else:
|
|
return LogiqueEchecs.MVT_OBSTRUCTION
|
|
return LogiqueEchecs.MVT_OK # Vide
|
|
else:
|
|
return LogiqueEchecs.MVT_N_AUTORISE
|
|
|
|
def mvtPossibleSansEchecCavalier(self, x1, y1, x2, y2):
|
|
if (abs(x2-x1) == 2 and abs(y2-y1) == 1) or (abs(y2-y1) == 2 and abs(x2-x1) == 1):
|
|
return LogiqueEchecs.MVT_OK
|
|
else:
|
|
return LogiqueEchecs.MVT_N_AUTORISE
|
|
|
|
def mvtPossibleSansEchec(self, x1, y1, x2, y2):
|
|
pion = self.grille[x1][y1]
|
|
if self.aSonTour(pion):
|
|
if (x1 != x2 or y1 != y2):
|
|
if not self.aSonTour(self.grille[x2][y2]):
|
|
tPion = pion % 10
|
|
if tPion == 1: # Pion
|
|
return self.mvtPossibleSansEchecPion(x1, y1, x2, y2)
|
|
elif tPion == 2: # Tour
|
|
return self.mvtPossibleSansEchecTour(x1, y1, x2, y2)
|
|
elif tPion == 3: # Cavalier
|
|
return self.mvtPossibleSansEchecCavalier(x1, y1, x2, y2)
|
|
elif tPion == 4: # Fou
|
|
return self.mvtPossibleSansEchecFou(x1, y1, x2, y2)
|
|
elif tPion == 5: # Dame
|
|
tour = self.mvtPossibleSansEchecTour(x1, y1, x2, y2)
|
|
fou = self.mvtPossibleSansEchecFou(x1, y1, x2, y2)
|
|
if tour == LogiqueEchecs.MVT_OK or fou == LogiqueEchecs.MVT_OK:
|
|
return LogiqueEchecs.MVT_OK
|
|
elif tour == LogiqueEchecs.MVT_OBSTRUCTION or fou == LogiqueEchecs.MVT_OBSTRUCTION:
|
|
return LogiqueEchecs.MVT_OBSTRUCTION
|
|
else:
|
|
return LogiqueEchecs.MVT_N_AUTORISE
|
|
elif tPion == 6: # Roi
|
|
if abs(x2-x1) <= 1 and abs(y2-y1) <= 1:
|
|
return LogiqueEchecs.MVT_OK
|
|
else:
|
|
return LogiqueEchecs.MVT_N_AUTORISE
|
|
else:
|
|
return LogiqueEchecs.MVT_PION_INC
|
|
else:
|
|
return LogiqueEchecs.MVT_SAUT_AMI
|
|
else:
|
|
return LogiqueEchecs.MVT_SUR_PLACE
|
|
else:
|
|
return LogiqueEchecs.MVT_SELECTION
|
|
return LogiqueEchecs.MVT_INCONNU
|
|
|
|
def mvtPossible(self, x1, y1, x2, y2):
|
|
test = self.mvtPossibleSansEchec(x1, y1, x2, y2)
|
|
if test == LogiqueEchecs.MVT_OK:
|
|
# On copie la partie actuelle pour tester le mouvement et vérifier l'échec
|
|
copie = copy.deepcopy(self);
|
|
copie.dPionSansEchec(x1, y1, x2, y2)
|
|
mvtsPossiblesTousAdverses = []
|
|
pionRoi = 6
|
|
if not self.joueur:
|
|
pionRoi += 10
|
|
roi = [-1, -1]
|
|
for x in range(0, LogiqueEchecs.CASES_COTE):
|
|
for y in range(0, LogiqueEchecs.CASES_COTE):
|
|
mvtsPossiblesTousAdverses += copie.mvtsPossiblesSansEchec(x, y)
|
|
if copie.grille[x][y] == pionRoi:
|
|
roi = [x, y]
|
|
if roi in mvtsPossiblesTousAdverses:
|
|
return LogiqueEchecs.MVT_ECHEC
|
|
else:
|
|
return test
|
|
else:
|
|
return test
|
|
|
|
def mvtsPossiblesSansEchec(self, x1, y1):
|
|
tableau = []
|
|
for x2 in range(0, LogiqueEchecs.CASES_COTE):
|
|
for y2 in range(0, LogiqueEchecs.CASES_COTE):
|
|
if self.mvtPossibleSansEchec(x1, y1, x2, y2) == LogiqueEchecs.MVT_OK:
|
|
tableau.append([x2, y2])
|
|
return tableau
|
|
|
|
def mvtsPossibles(self, x1, y1):
|
|
tableau = []
|
|
for x2 in range(0, LogiqueEchecs.CASES_COTE):
|
|
for y2 in range(0, LogiqueEchecs.CASES_COTE):
|
|
if self.mvtPossible(x1, y1, x2, y2) == LogiqueEchecs.MVT_OK:
|
|
tableau.append([x2, y2])
|
|
return tableau
|
|
|
|
def dPionSansEchec(self, x1, y1, x2, y2):
|
|
test = self.mvtPossibleSansEchec(x1, y1, x2, y2)
|
|
if test == LogiqueEchecs.MVT_OK:
|
|
self.grille[x1][y1], self.grille[x2][y2] = 0, self.grille[x1][y1]
|
|
self.joueur = not self.joueur
|
|
|
|
def vEchecMat(self):
|
|
"""
|
|
Vérifie si le joueur actuel est en échec et mat et prend les mesures nécessiares.
|
|
(CÀD Le joueur actuel ne peut effectuer aucun mouvement)
|
|
"""
|
|
for x in range(0, LogiqueEchecs.CASES_COTE):
|
|
for y in range(0, LogiqueEchecs.CASES_COTE):
|
|
if len(self.mvtsPossibles(x, y)) > 0:
|
|
return False
|
|
self.partieFinie = True
|
|
self.victorieux = not self.joueur
|
|
return True
|
|
|
|
def dPion(self, x1, y1, x2, y2):
|
|
test = self.mvtPossible(x1, y1, x2, y2)
|
|
retour = {
|
|
'valide': False,
|
|
'message': test,
|
|
'deplacer': [], # Pions à déplacer
|
|
'supprimer': [], # Pions à supprimer
|
|
}
|
|
if test == LogiqueEchecs.MVT_OK:
|
|
retour['valide'] = True
|
|
if self.grille[x2][y2] > 0:
|
|
retour['supprimer'].append([x2, y2])
|
|
retour['deplacer'].append([x1, y1, x2, y2])
|
|
self.grille[x1][y1], self.grille[x2][y2] = 0, self.grille[x1][y1]
|
|
self.joueur = not self.joueur
|
|
self.vEchecMat()
|
|
return retour |