def realizar_enrroque(self, movimiento):
pieza_a_mover = self.obtener_pieza_de_casilla(
movimiento.casilla_inicial)
self.limpiar_casilla(movimiento.casilla_inicial)
self.colocar_pieza_en_casilla(pieza_a_mover,
movimiento.casilla_objetivo)
if movimiento.casilla_objetivo.columna == 2:
posicion_torre = Posicion.Posicion(movimiento.casilla_inicial.fila,
0)
pieza_torre = self.obtener_pieza_de_casilla(posicion_torre)
self.limpiar_casilla(posicion_torre)
posicion_torre.columna = 3
self.colocar_pieza_en_casilla(pieza_torre, posicion_torre)
##enrroque largo
elif movimiento.casilla_objetivo.columna == 6:
posicion_torre = Posicion.Posicion(movimiento.casilla_inicial.fila,
7)
pieza_torre = self.obtener_pieza_de_casilla(posicion_torre)
self.limpiar_casilla(posicion_torre)
posicion_torre.columna = 5
self.colocar_pieza_en_casilla(pieza_torre, posicion_torre)
def colocar_enrroque(self,movimiento):
casilla_inicial = movimiento.casilla_inicial
casilla_objetivo = movimiento.casilla_objetivo
pieza_a_mover = self.piezas[casilla_inicial.calcular_posicion_tablero()]
pieza_a_mover.calcular_posicion_en_tablero(casilla_objetivo)
pieza_a_mover.mover_pieza()
self.piezas[casilla_inicial.calcular_posicion_tablero()] = None
if casilla_objetivo.columna == 2:
posicion_torre = Posicion.Posicion(casilla_inicial.fila,0)
torre = self.piezas[posicion_torre.calcular_posicion_tablero()]
self.piezas[posicion_torre.calcular_posicion_tablero()] = None
posicion_torre.columna = 3
torre.calcular_posicion_en_tablero(posicion_torre)
torre.mover_pieza()
self.piezas[posicion_torre.calcular_posicion_tablero()] = torre
elif casilla_objetivo.columna == 6:
posicion_torre = Posicion.Posicion(casilla_inicial.fila,7)
torre = self.piezas[posicion_torre.calcular_posicion_tablero()]
self.piezas[posicion_torre.calcular_posicion_tablero()] = None
posicion_torre.columna = 5
torre.calcular_posicion_en_tablero(posicion_torre)
torre.mover_pieza()
self.piezas[posicion_torre.calcular_posicion_tablero()] = torre
self.piezas[casilla_objetivo.calcular_posicion_tablero()] = pieza_a_mover
def posibles_movimientos_en_una_direccion(self, casilla_inicial,
avanzar_fila, avanzar_columna):
posibles_movimientos = deque()
color_de_pieza = self.obtener_color_de_pieza(casilla_inicial)
casilla_objetivo = Posicion.Posicion(casilla_inicial.fila,
casilla_inicial.columna)
casilla_objetivo.avanzar_casilla(avanzar_fila, avanzar_columna)
while True:
if not casilla_objetivo.validar_posicion():
break
pieza_casilla_objetivo = self.obtener_pieza_de_casilla(
casilla_objetivo)
if pieza_casilla_objetivo != 0:
if self.calculando_movimiento:
color_casilla_objetivo = self.obtener_color_de_pieza(
casilla_objetivo)
if color_de_pieza == color_casilla_objetivo:
break
posible_movimiento = Movimiento.Movimiento(
casilla_inicial, casilla_objetivo)
posibles_movimientos.append(posible_movimiento)
break
else:
posible_movimiento = Movimiento.Movimiento(
casilla_inicial, casilla_objetivo)
posibles_movimientos.append(posible_movimiento)
casilla_objetivo = Posicion.Posicion(
casilla_objetivo.fila + avanzar_fila,
casilla_objetivo.columna + avanzar_columna)
return posibles_movimientos
def colocar_lbl_img_jugadores(self): ##35,450
posicion_lbl_img_blancas = Posicion.Posicion(50,485)
posicion_lbl_img_negras = Posicion.Posicion(340,485)
if self.master.juego.tipo_de_juego == 1:
self.lbl_img_jugador1 = Label_IMG.Label_IMG(self.canvas,"jugador1")
self.lbl_img_jugador2 = Label_IMG.Label_IMG(self.canvas,"jugador2")
if self.master.juego.J1 == "B":
self.lbl_img_jugador1.colocar_posicion_en_tablero(posicion_lbl_img_blancas)
self.lbl_img_jugador2.colocar_posicion_en_tablero(posicion_lbl_img_negras)
else:
self.lbl_img_jugador1.colocar_posicion_en_tablero(posicion_lbl_img_negras)
self.lbl_img_jugador2.colocar_posicion_en_tablero(posicion_lbl_img_blancas)
elif self.master.juego.tipo_de_juego == 2:
self.lbl_img_jugador1 = Label_IMG.Label_IMG(self.canvas,"jugador")
self.lbl_img_jugador2 = Label_IMG.Label_IMG(self.canvas,"pc")
if self.master.juego.J1 == "B":
self.lbl_img_jugador1.colocar_posicion_en_tablero(posicion_lbl_img_blancas)
self.lbl_img_jugador2.colocar_posicion_en_tablero(posicion_lbl_img_negras)
else:
self.lbl_img_jugador1.colocar_posicion_en_tablero(posicion_lbl_img_negras)
self.lbl_img_jugador2.colocar_posicion_en_tablero(posicion_lbl_img_blancas)
elif self.master.juego.tipo_de_juego == 3:
self.lbl_img_jugador1 = Label_IMG.Label_IMG(self.canvas,"pc1")
self.lbl_img_jugador2 = Label_IMG.Label_IMG(self.canvas,"pc2")
if self.master.juego.J1 == "B":
self.lbl_img_jugador1.colocar_posicion_en_tablero(posicion_lbl_img_blancas)
self.lbl_img_jugador2.colocar_posicion_en_tablero(posicion_lbl_img_negras)
else:
self.lbl_img_jugador1.colocar_posicion_en_tablero(posicion_lbl_img_negras)
self.lbl_img_jugador2.colocar_posicion_en_tablero(posicion_lbl_img_blancas)
self.lbl_img_jugador1.colocar_imagen_en_tablero()
self.lbl_img_jugador2.colocar_imagen_en_tablero()
def es_movimiento_enrroque(self, movimiento):
filas = [0, 7]
columnas = [2, 6]
for fila in filas:
casilla_inicial = Posicion.Posicion(fila, 4)
for columna in columnas:
casilla_objetivo = Posicion.Posicion(fila, columna)
mov_tmp = Movimiento.Movimiento(casilla_inicial,
casilla_objetivo)
if mov_tmp.equals(movimiento):
return True
def posibles_movimientos_de_rey(self, casilla_inicial):
posibles_movimientos = deque()
color_de_pieza = self.obtener_color_de_pieza(casilla_inicial)
for fila in range(casilla_inicial.fila - 1, casilla_inicial.fila + 2):
for columna in range(casilla_inicial.columna - 1,
casilla_inicial.columna + 2):
casilla_objetivo = Posicion.Posicion(fila, columna)
if casilla_objetivo.equals(casilla_inicial):
continue
if casilla_objetivo.validar_posicion():
if self.calculando_movimiento:
color_objetivo = self.obtener_color_de_pieza(
casilla_objetivo)
pieza = abs(
self.obtener_pieza_de_casilla(casilla_objetivo))
if color_de_pieza == color_objetivo:
continue
posible_movimiento = Movimiento.Movimiento(
casilla_inicial, casilla_objetivo)
posibles_movimientos.append(posible_movimiento)
return posibles_movimientos
def cargar_lbl_img_turno(self):
posicion_lbl_img_turno = Posicion.Posicion(545,125)
self.lbl_img_turno_blancas = Label_IMG.Label_IMG(self.canvas,"turno_blancas")
self.lbl_img_turno_negras = Label_IMG.Label_IMG(self.canvas,"turno_negras")
self.lbl_img_turno_blancas.colocar_posicion_en_tablero(posicion_lbl_img_turno)
self.lbl_img_turno_negras.colocar_posicion_en_tablero(posicion_lbl_img_turno)
self.colocar_lbl_img_turno()
def imprimir_tablero(self):
etiqueta_de_fila = ['8', '7', '6', '5', '4', '3', '2', '1']
etiqueta_de_columna = " a b c d e f g h"
etiqueta_de_linea_inicial = " _______________________________________"
etiqueta_de_linea = " |____|____|____|____|____|____|____|____|"
print(etiqueta_de_linea_inicial)
for fila in range(0, 8):
columna = 0
fila_por_imprimir = ""
fila_por_imprimir += etiqueta_de_fila[fila] + " | "
for columna in range(0, 8):
posicion = Posicion.Posicion(fila, columna)
pieza_tablero = self.obtener_pieza_de_casilla(posicion)
if pieza_tablero == 0:
fila_por_imprimir += "__"
else:
if pieza_tablero > 0:
fila_por_imprimir += " " + str(pieza_tablero)
else:
fila_por_imprimir += str(pieza_tablero)
fila_por_imprimir += " | "
print(fila_por_imprimir)
print(etiqueta_de_linea)
print(etiqueta_de_columna)
def cargar_lbl_img_jaque(self):
posicion_lbl_img_jaque = Posicion.Posicion(565,125)
self.lbl_img_es_jaque = Label_IMG.Label_IMG(self.canvas,"jaque")
self.lbl_img_jaque_mate = Label_IMG.Label_IMG(self.canvas,"jaque_mate")
##falta agregar tablas
self.lbl_img_es_jaque.colocar_posicion_en_tablero(posicion_lbl_img_jaque)
self.lbl_img_jaque_mate.colocar_posicion_en_tablero(posicion_lbl_img_jaque)
self.colocar_lbl_img_jaque()
def generar_enrroque_blancas_corto(self, casillas_atacadas):
## | T | R | corto | T | R |
## 7,7 7,4 -> 7,5 7,6
posicion_rey = Posicion.Posicion(7, 4)
posicion_torre = Posicion.Posicion(7, 7)
posicion_rey_pieza = self.obtener_pieza_de_casilla(posicion_rey)
posicion_torre_pieza = self.obtener_pieza_de_casilla(posicion_torre)
if posicion_rey_pieza == 6 and posicion_torre_pieza == 4:
fila = 7
for columna in range(5, 7):
posicion = Posicion.Posicion(fila, columna)
pieza_de_casilla = self.obtener_pieza_de_casilla(posicion)
if pieza_de_casilla != 0 or self.es_casilla_atacada(
posicion, casillas_atacadas):
return None
casilla_objetivo = Posicion.Posicion(7, 6)
movimiento = Movimiento.Movimiento(posicion_rey, casilla_objetivo)
return movimiento
else:
return None
def posibles_movimientos_de_caballo(self, casilla_inicial):
posibles_movimientos = deque()
color_de_pieza = self.obtener_color_de_pieza(casilla_inicial)
unos = [-1, 1]
dos = [-2, 2]
for i in unos:
for j in dos:
casilla_objetivo = Posicion.Posicion(
casilla_inicial.fila + i, casilla_inicial.columna + j)
if casilla_objetivo.validar_posicion():
if self.calculando_movimiento:
color_objetivo = self.obtener_color_de_pieza(
casilla_objetivo)
if color_de_pieza == color_objetivo:
continue
posible_movimiento = Movimiento.Movimiento(
casilla_inicial, casilla_objetivo)
posibles_movimientos.append(posible_movimiento)
for i in dos:
for j in unos:
casilla_objetivo = Posicion.Posicion(
casilla_inicial.fila + i, casilla_inicial.columna + j)
if casilla_objetivo.validar_posicion():
if self.calculando_movimiento:
color_objetivo = self.obtener_color_de_pieza(
casilla_objetivo)
if color_de_pieza == color_objetivo:
continue
posible_movimiento = Movimiento.Movimiento(
casilla_inicial, casilla_objetivo)
posibles_movimientos.append(posible_movimiento)
return posibles_movimientos
def colocar_piezas_en_tablero(self):
self.piezas = []
for fila in range(0,8):
for columna in range(0,8):
casilla_actual = Posicion.Posicion(fila,columna)
pieza_actual = self.master.juego.tablero.obtener_pieza_de_casilla(casilla_actual)
if pieza_actual == 0:
self.piezas.append(None)
else:
self.contar_captura(pieza_actual)
pieza = Pieza.Pieza(self.canvas,pieza_actual)
pieza.calcular_posicion_en_tablero(casilla_actual)
pieza.colocar_imagen_en_tablero()
self.piezas.append(pieza)
def realizar_captura_al_paso(self, movimiento):
pieza_a_mover = self.obtener_pieza_de_casilla(
movimiento.casilla_inicial)
color_pieza = self.get_color_pieza(movimiento.casilla_inicial)
self.limpiar_casilla(movimiento.casilla_inicial)
self.colocar_pieza_en_casilla(pieza_a_mover,
movimiento.casilla_objetivo)
if color_pieza == Turno.BLANCAS:
fila = movimiento.casilla_objetivo.fila + 1
elif color_pieza == Turno.NEGRAS:
fila = movimiento.casilla_objetivo.fila - 1
posicion_de_captura = Posicion.Posicion(
fila, movimiento.casilla_objetivo.columna)
self.limpiar_casilla(posicion_de_captura)
def generar_posibles_movimientos(self):
posibles_movimientos = deque()
posibles_movimientos_peon = deque()
posibles_movimientos_caballo = deque()
posibles_movimientos_alfil = deque()
posibles_movimientos_torre = deque()
posibles_movimientos_dama = deque()
posibles_movimientos_rey = deque()
for fila in range(0, 8):
for columna in range(0, 8):
casilla = Posicion.Posicion(fila, columna)
pieza_casilla_inicial = abs(
self.obtener_pieza_de_casilla(casilla))
if pieza_casilla_inicial == 1:
posibles_movimientos_peon.extend(
self.posibles_movimientos_de_peon(casilla))
elif pieza_casilla_inicial == 2:
posibles_movimientos_caballo.extend(
self.posibles_movimientos_de_caballo(casilla))
elif pieza_casilla_inicial == 3:
posibles_movimientos_alfil.extend(
self.posibles_movimientos_de_alfil(casilla))
elif pieza_casilla_inicial == 4:
posibles_movimientos_torre.extend(
self.posibles_movimientos_de_torre(casilla))
elif pieza_casilla_inicial == 5:
posibles_movimientos_dama.extend(
self.posibles_movimientos_de_dama(casilla))
elif pieza_casilla_inicial == 6:
posibles_movimientos_rey.extend(
self.posibles_movimientos_de_rey(casilla))
else:
continue
posibles_movimientos.extend(posibles_movimientos_rey)
posibles_movimientos.extend(posibles_movimientos_dama)
posibles_movimientos.extend(posibles_movimientos_torre)
posibles_movimientos.extend(posibles_movimientos_alfil)
posibles_movimientos.extend(posibles_movimientos_caballo)
posibles_movimientos.extend(posibles_movimientos_peon)
return posibles_movimientos
def __init__(self,color,pieza,columna,fila):
self.color = color
self.pieza = pieza
self.posicion = Posicion.Posicion(fila,columna)
def colocar_posicion_en_tablero(self, posicion):
self.posicion_en_tablero = Posicion.Posicion(posicion.fila,
posicion.columna)
def posibles_movimientos_de_peon(self, casilla_inicial):
posibles_movimientos = deque()
color_de_pieza = self.obtener_color_de_pieza(casilla_inicial)
if color_de_pieza == 'B':
casilla_objetivo = Posicion.Posicion(casilla_inicial.fila - 1,
casilla_inicial.columna)
else:
casilla_objetivo = Posicion.Posicion(casilla_inicial.fila + 1,
casilla_inicial.columna)
fila_actual = casilla_objetivo.fila
for i in range(casilla_inicial.columna - 1,
casilla_inicial.columna + 2):
casilla_objetivo = Posicion.Posicion(fila_actual, i)
if not casilla_objetivo.validar_posicion():
continue
pieza_casilla_objetivo = self.obtener_pieza_de_casilla(
casilla_objetivo)
if i == casilla_inicial.columna:
if pieza_casilla_objetivo == 0:
posible_movimiento = Movimiento.Movimiento(
casilla_inicial, casilla_objetivo)
posibles_movimientos.append(posible_movimiento)
if color_de_pieza == 'B' and casilla_inicial.fila == 6:
fila_actual = casilla_objetivo.fila
casilla_objetivo = Posicion.Posicion(
casilla_objetivo.fila - 1, i) #
pieza_casilla_objetivo = self.obtener_pieza_de_casilla(
casilla_objetivo)
if pieza_casilla_objetivo == 0:
posible_movimiento = Movimiento.Movimiento(
casilla_inicial, casilla_objetivo)
posibles_movimientos.append(posible_movimiento)
elif color_de_pieza == 'N' and casilla_inicial.fila == 1:
fila_actual = casilla_objetivo.fila
casilla_objetivo = Posicion.Posicion(
casilla_objetivo.fila + 1, i) #
pieza_casilla_objetivo = self.obtener_pieza_de_casilla(
casilla_objetivo)
if pieza_casilla_objetivo == 0:
posible_movimiento = Movimiento.Movimiento(
casilla_inicial, casilla_objetivo)
posibles_movimientos.append(posible_movimiento)
else:
if pieza_casilla_objetivo != 0:
if self.calculando_movimiento:
tmp_color_objetivo = self.obtener_color_de_pieza(
casilla_objetivo)
if tmp_color_objetivo == color_de_pieza:
break
posible_movimiento = Movimiento.Movimiento(
casilla_inicial, casilla_objetivo)
posibles_movimientos.append(posible_movimiento)
return posibles_movimientos
def generar_posiciones_de_capturas(self):
## Posiciones de Blancas Capturadas
##Peones
# [ [211.98 , 460.32] , [211.98 , 485.32] , [211.98 , 510.32] , [241.38 , 460.32] , [241.38 , 485.32] , [241.38 , 510.32] , [271.02 , 475.32] , [271.02 , 495.32] ]
self.posiciones_de_capturas_blancas_peones = []
self.posiciones_de_capturas_blancas_peones.append(Posicion.Posicion(211.98 , 460.32))
self.posiciones_de_capturas_blancas_peones.append(Posicion.Posicion(211.98 , 485.32))
self.posiciones_de_capturas_blancas_peones.append(Posicion.Posicion(211.98 , 510.32))
self.posiciones_de_capturas_blancas_peones.append(Posicion.Posicion(241.38 , 460.32))
self.posiciones_de_capturas_blancas_peones.append(Posicion.Posicion(241.38 , 485.32))
self.posiciones_de_capturas_blancas_peones.append(Posicion.Posicion(241.38 , 510.32))
self.posiciones_de_capturas_blancas_peones.append(Posicion.Posicion(271.02 , 475.32))
self.posiciones_de_capturas_blancas_peones.append(Posicion.Posicion(271.02 , 495.32))
##Caballos
# [ [140 , 458.90] , [140 , 511.32] ]
self.posiciones_de_capturas_blancas_caballos = []
self.posiciones_de_capturas_blancas_caballos.append(Posicion.Posicion(140.00 , 458.90))
self.posiciones_de_capturas_blancas_caballos.append(Posicion.Posicion(140.00 , 511.32))
##Alfiles
# [ [181 , 473.32] , [181 , 496.32] ]
self.posiciones_de_capturas_blancas_alfiles = []
self.posiciones_de_capturas_blancas_alfiles.append(Posicion.Posicion(181 , 473.32))
self.posiciones_de_capturas_blancas_alfiles.append(Posicion.Posicion(181 , 496.32))
##Torres
# [ [102.00 , 458.90] , [102.00 , 511.32] ]
self.posiciones_de_capturas_blancas_torres = []
self.posiciones_de_capturas_blancas_torres.append(Posicion.Posicion(102.00 , 458.90))
self.posiciones_de_capturas_blancas_torres.append(Posicion.Posicion(102.00 , 511.32))
##Dama
# [ [140 , 485.32] ]
self.posiciones_de_capturas_blancas_dama = []
self.posiciones_de_capturas_blancas_dama.append(Posicion.Posicion(140 , 485.32))
## Posiciones de Negras Capturadas
##Peones
# [ [499.98 , 460.32] , [499.98 , 485.32] , [499.98 , 510.32] , [529.38 , 460.32] , [529.38 , 485.32] , [529.38 , 510.32] , [559.02 , 475.32] , [559.02 , 495.32] ]
self.posiciones_de_capturas_negras_peones = []
self.posiciones_de_capturas_negras_peones.append(Posicion.Posicion(499.98 , 460.32))
self.posiciones_de_capturas_negras_peones.append(Posicion.Posicion(499.98 , 485.32))
self.posiciones_de_capturas_negras_peones.append(Posicion.Posicion(499.98 , 510.32))
self.posiciones_de_capturas_negras_peones.append(Posicion.Posicion(529.38 , 460.32))
self.posiciones_de_capturas_negras_peones.append(Posicion.Posicion(529.38 , 485.32))
self.posiciones_de_capturas_negras_peones.append(Posicion.Posicion(529.38 , 510.32))
self.posiciones_de_capturas_negras_peones.append(Posicion.Posicion(559.02 , 475.32))
self.posiciones_de_capturas_negras_peones.append(Posicion.Posicion(559.02 , 495.32))
##Caballos
# [ [425.90 , 458.90] , [425.90 , 511.32] ]
self.posiciones_de_capturas_negras_caballos = []
self.posiciones_de_capturas_negras_caballos.append(Posicion.Posicion(425.90 , 458.90))
self.posiciones_de_capturas_negras_caballos.append(Posicion.Posicion(425.90 , 511.32))
##Alfiles
# [ [464.90 , 473.32] , [464.90 , 496.32] ]
self.posiciones_de_capturas_negras_alfiles = []
self.posiciones_de_capturas_negras_alfiles.append(Posicion.Posicion(464.90 , 473.32))
self.posiciones_de_capturas_negras_alfiles.append(Posicion.Posicion(464.90 , 496.32))
##Torres
# [ [387.90 , 458.90] , [387.90 , 511.32] ]
self.posiciones_de_capturas_negras_torres = []
self.posiciones_de_capturas_negras_torres.append(Posicion.Posicion(387.90 , 458.90))
self.posiciones_de_capturas_negras_torres.append(Posicion.Posicion(387.90 , 511.32))
##Dama
# [ [425.9 , 485.32] ]
self.posiciones_de_capturas_negras_dama = []
self.posiciones_de_capturas_negras_dama.append(Posicion.Posicion(425.90 , 485.32))
def generar_posicion_de_tablero(self,fila,columna):
largo_filas = self.fila_final - self.fila_inicial
largo_columnas = self.columna_final - self.columna_inicial
posicion_seleccionada = Posicion.Posicion(int((fila-self.fila_inicial)//self.largo_fila),int((columna-self.columna_inicial)//self.largo_columna))
return posicion_seleccionada