318 lines
9.7 KiB
Python
Executable file
318 lines
9.7 KiB
Python
Executable file
CASES_COTE = 8
|
|
|
|
|
|
class LogiqueEchecs:
|
|
|
|
# grille = None
|
|
# joueur = True
|
|
|
|
def __init__(self):
|
|
self.grille = []
|
|
self.cGrille()
|
|
self.remplirGrille()
|
|
self.joueur = True
|
|
self.nvPartie()
|
|
|
|
@staticmethod
|
|
def eNoir(xD, yD): # TODO Peut être considérablement amélioré
|
|
i = 1
|
|
for x in range(0, CASES_COTE):
|
|
i += 1
|
|
for y in range(0, CASES_COTE):
|
|
i += 1
|
|
if x == xD and y == yD:
|
|
return i % 2
|
|
|
|
def cGrille(self):
|
|
for x in range(CASES_COTE):
|
|
colonne = []
|
|
for y in range(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 nvPartie(self):
|
|
self.cGrille()
|
|
self.remplirGrille()
|
|
self.joueur = True
|
|
|
|
def cPion(self, x, y, piece):
|
|
"""
|
|
"""
|
|
self.grille[x][y] = piece
|
|
return True
|
|
|
|
def mvtPossible(self, x1, y1, x2, y2):
|
|
pion = self.grille[x1][y1]
|
|
if (pion >= 10 and self.joueur == False) or \
|
|
(pion < 10 and self.joueur == True):
|
|
if pion > 0 and self.grille[x2][y2] <= 0:
|
|
tPion = pion % 10
|
|
if tPion == 1:
|
|
if x1 == x2:
|
|
if self.joueur:
|
|
if y2 == y1 - 1:
|
|
return True
|
|
else:
|
|
return -4
|
|
else:
|
|
if y2 == y1 + 1:
|
|
return True
|
|
else:
|
|
return -4
|
|
else:
|
|
return -4
|
|
elif tPion == 6:
|
|
if x2 <= x1 + 1 and x2 >= x1 - 1 and y2 <= y1 + 1 and y2 >= y1 - 1 \
|
|
and (x1 != x2 or y1 != y2):
|
|
return True
|
|
else:
|
|
return -4
|
|
else:
|
|
return -3
|
|
|
|
return True
|
|
else:
|
|
return -2
|
|
else:
|
|
return -1
|
|
|
|
def dPion(self, x1, y1, x2, y2):
|
|
test = self.mvtPossible(x1, y1, x2, y2)
|
|
if test == True:
|
|
self.grille[x2][y2] = self.grille[x1][y1]
|
|
self.grille[x1][y1] = 0
|
|
# self.joueur = not self.joueur # DEBUG
|
|
return True
|
|
else:
|
|
return test
|
|
|
|
# GUI
|
|
|
|
from tkinter import *
|
|
|
|
DECX = 0
|
|
DECY = 0
|
|
COTE_CASE = 50
|
|
MARGE_PIONS = 5
|
|
TEMPS_ANIM = 200
|
|
INTER_ANIM = 10
|
|
|
|
class PlateauTk:
|
|
|
|
def __init__(self):
|
|
|
|
self.fen = None
|
|
self.can = None
|
|
self.chaine = None
|
|
self.grilleDamier = []
|
|
self.imagesOriginales = []
|
|
self.imagesRedim = []
|
|
self.photos = []
|
|
self.grillePions = []
|
|
self.animations = []
|
|
|
|
self.dEtape = True
|
|
self.dx1 = -1
|
|
self.dy1 = -1
|
|
self.dx2 = -1
|
|
self.dy2 = -1
|
|
self.logique = LogiqueEchecs()
|
|
|
|
self.creerFen()
|
|
self.importerImages()
|
|
self.redimImages()
|
|
|
|
self.cDamier()
|
|
self.cGrille()
|
|
self.remplirGrille(self.logique.grille)
|
|
|
|
def creerFen(self):
|
|
self.fen = Tk()
|
|
self.fen.title("Jeu d'Échecs")
|
|
self.can = Canvas(self.fen, width=COTE_CASE * CASES_COTE,
|
|
height=COTE_CASE * CASES_COTE, bg="ivory")
|
|
self.can.grid(row=0, column=1, columnspan=3)
|
|
self.can.bind('<Button-1>', self.clic)
|
|
self.chaine = Label(self.fen, text="Aux blancs")
|
|
self.chaine.grid(row=2, column=2, padx=3, pady=3)
|
|
# Button(self.fen, text="Nv. Partie", command=f_nvPartie).grid(row=2, \
|
|
# column=1, padx=3, pady=3)
|
|
Button(self.fen, text="Quitter", command=self.fen.destroy).grid(row=2,
|
|
column=3, padx=3, pady=3)
|
|
|
|
def statut(self, texte, delai=0):
|
|
self.chaine.config(text=texte)
|
|
# TODO Timeout effacer si parametre / Liste
|
|
|
|
def importerImages(self):
|
|
for piece in range(0, 21):
|
|
nom = 'sprites/'
|
|
if piece % 10 == 1:
|
|
nom += 'pion'
|
|
elif piece % 10 == 2:
|
|
nom += 'tour'
|
|
elif piece % 10 == 3:
|
|
nom += 'cavalier'
|
|
elif piece % 10 == 4:
|
|
nom += 'fou'
|
|
elif piece % 10 == 5:
|
|
nom += 'dame'
|
|
elif piece % 10 == 6:
|
|
nom += 'roi'
|
|
else:
|
|
self.imagesOriginales.append('')
|
|
continue
|
|
if piece < 10:
|
|
nom += 'B'
|
|
else:
|
|
nom += 'N'
|
|
nom += '.gif'
|
|
self.imagesOriginales.append(PhotoImage(file=nom))
|
|
|
|
def redimImages(self):
|
|
sample = int(504 / (COTE_CASE - MARGE_PIONS))
|
|
for piece in range(0, 21):
|
|
if self.imagesOriginales[piece] != '':
|
|
self.imagesRedim.append(self.imagesOriginales[piece].
|
|
subsample(sample))
|
|
else:
|
|
self.imagesRedim.append('')
|
|
|
|
# Dessin
|
|
def cCase(self, x, y):
|
|
if LogiqueEchecs.eNoir(x, y):
|
|
couleur = '#D18B47'
|
|
else:
|
|
couleur = '#FFCE9E'
|
|
return self.can.create_rectangle(x * COTE_CASE, y * COTE_CASE,
|
|
(x + 1) * COTE_CASE, (y + 1) * COTE_CASE, fill=couleur)
|
|
|
|
def cDamier(self):
|
|
self.grilleDamier = []
|
|
for x in range(0, CASES_COTE):
|
|
colonne = []
|
|
for y in range(0, CASES_COTE):
|
|
colonne.append(self.cCase(x + DECX, y + DECY))
|
|
self.grilleDamier.append(colonne)
|
|
|
|
def cPion(self, x, y, piece):
|
|
if piece > 0:
|
|
self.grillePions[x][y] = self.can.create_image((x + .5) * COTE_CASE,
|
|
(y + .5) * COTE_CASE, image=self.imagesRedim[piece])
|
|
else:
|
|
self.grillePions[x][y] = False
|
|
|
|
def cGrille(self):
|
|
self.grillePions = []
|
|
for x in range(0, CASES_COTE): # Crée self.grillePions
|
|
colonne = []
|
|
for y in range(0, CASES_COTE):
|
|
colonne.append(False)
|
|
self.grillePions.append(colonne)
|
|
|
|
def remplirGrille(self, j_grilleF):
|
|
for x in range(0, CASES_COTE): # Remplis self.grillePions
|
|
for y in range(0, CASES_COTE):
|
|
self.cPion(x, y, j_grilleF[x][y])
|
|
|
|
# Interaction
|
|
def statutPrendre(self):
|
|
if self.logique.joueur:
|
|
joueur = 'blancs'
|
|
else:
|
|
joueur = 'noirs'
|
|
self.statut('Prendre (' + joueur + ')')
|
|
|
|
@staticmethod
|
|
def dPionAnimCoords(i):
|
|
x = i['x1'] + (i['x2']-i['x1']) * (i['avancement']/i['total'])
|
|
y = i['y1'] + (i['y2']-i['y1']) * (i['avancement']/i['total'])
|
|
return [x, y]
|
|
|
|
def dPionAnim(self):
|
|
animationsNv = []
|
|
for i in self.animations:
|
|
if i['avancement'] < i['total']:
|
|
coords = self.dPionAnimCoords(i)
|
|
self.can.coords(i['pion'], coords[0], coords[1])
|
|
i['avancement'] += INTER_ANIM
|
|
animationsNv.append(i)
|
|
else:
|
|
self.can.coords(i['pion'], i['x2'], i['y2'])
|
|
self.animations = animationsNv
|
|
if len(animationsNv):
|
|
self.fen.after(INTER_ANIM, self.dPionAnim)
|
|
|
|
def cdPionAnim(self, x1, y1, x2, y2, pion):
|
|
animation = {
|
|
'x1': x1,
|
|
'y1': y1,
|
|
'x2': x2,
|
|
'y2': y2,
|
|
'pion': pion,
|
|
'total': TEMPS_ANIM,
|
|
'avancement': 0
|
|
}
|
|
|
|
if not len(self.animations):
|
|
self.animations.append(animation)
|
|
self.dPionAnim()
|
|
else:
|
|
for i in self.animations:
|
|
if i['pion'] == pion: # Si une animation pour ce pion existe
|
|
# déjà, on la reprend et on la modifie
|
|
coords = self.dPionAnimCoords(i)
|
|
i['x1'] = coords[0]
|
|
i['y1'] = coords[1]
|
|
i['x2'] = x2
|
|
i['y2'] = y2
|
|
# i['total'] = i['total'] - i['avancement']
|
|
i['total'] = TEMPS_ANIM
|
|
i['avancement'] = 0
|
|
return
|
|
self.animations.append(animation)
|
|
|
|
|
|
def dPion(self, x1, y1, x2, y2):
|
|
test = self.logique.dPion(x1, y1, x2, y2)
|
|
if test == True:
|
|
self.grillePions[x2][y2], self.grillePions[x1][y1] = \
|
|
self.grillePions[x1][y1], False
|
|
self.cdPionAnim((x1 + .5) * COTE_CASE, (y1 + .5) * COTE_CASE, \
|
|
(x2 + .5) * COTE_CASE, (y2 + .5) * COTE_CASE, \
|
|
self.grillePions[x2][y2])
|
|
return True
|
|
else:
|
|
# TODO Messages corrects
|
|
self.statut('Impossible ! (' + str(test) + ')')
|
|
return False
|
|
|
|
def dClic(self, x, y):
|
|
# if not len(self.animations):
|
|
if self.dEtape:
|
|
self.dx1, self.dy1 = x, y
|
|
# TODO Colorer case
|
|
self.statut('Poser')
|
|
else:
|
|
self.dx2, self.dy2 = x, y
|
|
self.dPion(self.dx1, self.dy1, self.dx2, self.dy2)
|
|
self.statutPrendre()
|
|
self.dEtape = not self.dEtape
|
|
|
|
def clic(self, event):
|
|
x = event.x // COTE_CASE
|
|
y = event.y // COTE_CASE
|
|
self.dClic(x, y)
|
|
|
|
p = PlateauTk()
|
|
|
|
# TODO Un jeu (canvas) et un frontend (fenetre)
|