diff --git a/Damas.py b/Damas.py index 3f59533..eff0273 100644 --- a/Damas.py +++ b/Damas.py @@ -1,11 +1,11 @@ -from Ficha import Ficha +from Ficha import Casilla import os import copy #Variables: #Tablero predeterminado para la partida. -tablero = [[0, Ficha(0, "A2", 0), 0, Ficha(0, "A4", 0), 0, Ficha(0, "A6", 0), 0, Ficha(0, "A8", 0)], +"""tablero = [[0, Ficha(0, "A2", 0), 0, Ficha(0, "A4", 0), 0, Ficha(0, "A6", 0), 0, Ficha(0, "A8", 0)], [Ficha(0, "B1", 0), 0, Ficha(0, "B3", 0), 0, Ficha(0, "B5", 0), 0, Ficha(0, "B7", 0), 0], @@ -19,7 +19,20 @@ [0, Ficha(1, "G2", 0), 0, Ficha(1, "G4", 0), 0, Ficha(1, "G6", 0), 0, Ficha(1, "G8", 0)], - [Ficha(1, "H1", 0), 0, Ficha(1, "H3", 0), 0, Ficha(1, "H5", 0), 0, Ficha(1, "H7", 0), 0]] + [Ficha(1, "H1", 0), 0, Ficha(1, "H3", 0), 0, Ficha(1, "H5", 0), 0, Ficha(1, "H7", 0), 0]]""" +tablero = [[0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0]] +#Disponer las casillas vacias y con fichas en el tablero +for y in range(8): + for x in range(8): + if (y == 0 or y == 1 or y == 2) and ((y-x)%2 != 0): + tablero[y][x] = Casilla(0,0, chr(65+y)+str(x+1),False) + elif (y == 5 or y == 6 or y == 7) and ((y-x)%2 != 0): + tablero[y][x] = Casilla(1,0, chr(65+y)+str(x+1),False) + else: + tablero[y][x] = Casilla(0,0, chr(65+x)+str(x+1),True) + #Dar los eventos a cada casilla + #tablero[a][b].connect("clicked", selecionarMovi, tablero[a][b].posicion) + #tablero[a][b].connect("enter", hover, tablero[a][b].posicion) #Indica si el juego debe continuar o no @@ -60,7 +73,7 @@ def verTablero(): #Bucle que recorre el tablero e imprime un guión en el caso de que una casilla esté vacia o la ficha correspondiente. for x in range(8): - if type(tablero[y][x]) == int: + if tablero[y][x].vacia == True: linea += "- " else: linea += tablero[y][x].verFicha() + " " @@ -74,6 +87,11 @@ def verTablero(): #Comprueba si la entrada del usuario es valida def entradaPermitida(movimiento): + + c1 = ord(movimiento[0]) - 65 + c2 = int(movimiento[1]) - 1 + c3 = ord(movimiento[2]) - 65 + c4 = int(movimiento[3]) - 1 #Comprueba si la orden está compuesta por 4 caracteres longitud = len(movimiento) @@ -81,55 +99,6 @@ def entradaPermitida(movimiento): print " Fallo: Debe introducir 4 caracteres. \n" return False - #Caracter1 - - #Convierte el carácter a un número - c1 = ord(movimiento[0]) - 65 - - #Comprueba si es una letra mayuscula entre A y H - if (c1 > 7 or c1 < 0): - print " Fallo primer caracter: " + movimiento[0] + " El caracter debe estar entre A y H. \n" - return False - - #Caracter2 - - #Devuelve Falso en caso de que el caracter no sea un entero. - try: - c2 = int(movimiento[1])-1 - except ValueError: - print " Fallo segundo caracter: " + movimiento[1] + " El numero debe estar estar entre 1 y 8. \n" - return False - - #Comprueba si es un número entre 1 y 8 - if c2 > 7 or c2 < 0: - print " Fallo segundo caracter: " + movimiento[1] + " El numero debe estar estar entre 1 y 8. \n" - return False - - #Caracter3 - - #Convierte el caracter a un numero - c3 = ord(movimiento[2]) - 65 - - #Comprueba si es una letra mayuscula entre A y H - if (c3 > 7 or c3 < 0): - print " Fallo tercer caracter: " + movimiento[2] + " El caracter debe estar entre A y H. \n" - return False - - #Caracter4 - - #Devuelve Falso en caso de que el caracter no sea un entero. - try: - c4 = int(movimiento[3])-1 - except ValueError: - print " Fallo cuarto caracter: " + movimiento[3] + " El numero debe estar estar entre 1 y 8. \n" - return False - - #Comprueba si es un número entre 1 y 8 - if c4 > 7 or c4 < 0: - print " Fallo cuarto caracter: " + movimiento[3] + " El numero debe estar estar entre 1 y 8. \n" - return False - - #Buscamos que el movimiento sea solo en las casillas blancas if (abs(c3) - c4+1) % 2 != 0: @@ -142,45 +111,41 @@ def entradaPermitida(movimiento): print " Solo se puede mover en diagonal. \n" return False - #Try-except que captura el caso de que la casilla no tenga ficha - try: - #Comprueba que el movimiento de los peones solo es de una unidad - if (tablero[c1][c2].tipo == 0) and calcularDistancia(c1, c3) != 1: + + #Comprueba que el movimiento de los peones solo es de una unidad + if (tablero[c1][c2].tipo == 0) and calcularDistancia(c1, c3) != 1: - print " Los peones solo se pueden mover con distancia 1. \n" - return False + print " Los peones solo se pueden mover con distancia 1. \n" + return False - #Comprueba que no se haya movido la ficha del jugador rival - if ((tablero [c1][c2].color == 0) and (turno == "Blancas")) or ((tablero [c1][c2].color == 1) and (turno == "Negras")): + #Comprueba que no se haya movido la ficha del jugador rival + if ((tablero [c1][c2].color == 0) and (turno == "Blancas")) or ((tablero [c1][c2].color == 1) and (turno == "Negras")): - print " No puede mover las fichas del jugador contrario. Tramposo!! \n" - return False + print " No puede mover las fichas del jugador contrario. Tramposo!! \n" + return False - #Comprueba que la ficha que se quiere comer no sea del mismo color que la que come. - if (tablero[c3][c4] != 0) and (tablero[c1][c2].color == tablero[c3][c4].color): - print " No se pueden comer fichas propias. \n" - return False - - #Calculamos la distancia y la direccion de las coordenadas (x, y) - distancia = calcularDistancia(c1, c3) - x,y = direcMovimiento(c1, c2, c3, c4) + #Comprueba que la ficha que se quiere comer no sea del mismo color que la que come. + if (tablero[c3][c4].vacia == False) and (tablero[c1][c2].color == tablero[c3][c4].color): + print " No se pueden comer fichas propias. \n" + return False + + #Calculamos la distancia y la direccion de las coordenadas (x, y) + distancia = calcularDistancia(c1, c3) + x,y = direcMovimiento(c1, c2, c3, c4) - #Comprueba que las reinas no salten ningún peón - if (tablero[c1][c2].tipo == 1) and (distancia != 1): + #Comprueba que las reinas no salten ningún peón + if (tablero[c1][c2].tipo == 1) and (distancia != 1): - i = 1 - while (i != distancia): + i = 1 + while (i != distancia): + + lado = i * x + arriba = i * y + i += 1 - lado = i * x - arriba = i * y - i += 1 - - if tablero[c1 + lado][c2 + arriba] != 0: - print " Las reinas no pueden saltar peones. \n" - return False - except AttributeError: - print " La casilla esta vacia \n" - return False + if tablero[c1 + lado][c2 + arriba].vacia == False: + print " Las reinas no pueden saltar peones. \n" + return False #En caso de que no se cumpla ningun caso anterior, quiere decir que la entrada del usuario ha sido correcta, por lo que devuelve verdadero return True @@ -196,7 +161,7 @@ def puedeMover(c1, c2, c3, c4): global seguir #si la posición a la que se mueve está vacia llama a mover, sino llama a comerficha - if tablero[c3][c4] == 0: + if tablero[c3][c4].vacia == True: mover(c1, c2, c3, c4) else: @@ -208,7 +173,7 @@ def puedeMover(c1, c2, c3, c4): #llama a comerficha si la posicion siguiente esta vacia si salta un error es porque la ficha se colocaría fuera del tablero, en cuyo caso se captura try: - if (c4 != 0) and (tablero[c3 + x][c4 + y] == 0): + if (c4 != 0) and (tablero[c3 + x][c4 + y].vacia == True): comerFicha(c1, c2, c3, c4) comerEnCadena(c3 + x,c4 + y) @@ -233,15 +198,15 @@ def direcMovimiento(c1, c2, c3, c4): def mover(c1, c2, c3, c4): #Pasamos la antigua ficha a la nueva posicion - tablero[c3][c4] = tablero[c1][c2] + tablero[c3][c4].color = tablero[c1][c2].color + + tablero[c3][c4].tipo = tablero[c1][c2].tipo - #Borramos la ficha de la antigua posicion - tablero[c1][c2] = 0 + #Borramos la ficha de la antigua posicion y la agregamos en la nueva + tablero[c1][c2].vacia = True + tablero[c3][c4].vacia = False - #posiNueva es el nombre de la posición en la que se colocará la ficha. - posiNueva = str(c3 + 65) + str(c4 + 1) - #Damos al atributo posicion de la ficha la nueva posicion - tablero[c3][c4].posicion = posiNueva + promociona(c3, c4) @@ -253,17 +218,19 @@ def comerFicha(c1, c2, c3, c4): x,y = direcMovimiento(c1, c2, c3, c4) + #Pasamos la antigua ficha a la nueva posicion - tablero[c3 + x][c4 + y] = tablero[c1][c2] + tablero[c3+x][c4+y].color = tablero[c1][c2].color - #Borramos la posicion antigua y la de la ficha que se ha comido - tablero[c3][c4] = 0 - tablero[c1][c2] = 0 + tablero[c3+x][c4+y].tipo = tablero[c1][c2].tipo + + #Borramos la posicion antigua y la de la ficha que se ha comido y agregamos la nueva + tablero[c1][c2].vacia = True + tablero[c3][c4].vacia = True + + + tablero[c3+x][c4+y].vacia = False - #posiNueva es el nombre de la posición en la que se colocará la ficha. - posiNueva = str(c3 + x + 65) + str(c4 + y + 1) - #Damos al atributo posicion de la ficha la nueva posicion - tablero[c3 + x][c4 + y].posicion = posiNueva promociona(c3 + x, c4 + y) @@ -314,7 +281,6 @@ def promociona(c3, c4): tablero[c3][c4].tipo = 1 - #Función que devuelve la lista de los posibles movimientos que puede hacer la ficha. def calcularPosibles(c3,c4): #Creamos posibles y posibles copia, "posibles" será donde se almacenarán los posibles movimientos, "posiblesCopia" sirve para que si no ha cambiado nada en la siguiente iteración termine de buscar posibilidades, ya que no hay más. @@ -324,8 +290,21 @@ def calcularPosibles(c3,c4): #Es el primer valor, y desde donde se empezarán a analizar las posibles opciones. original = str(c3) + str(c4) posibles.append([original]) - tableroPosibles = copy.deepcopy(tablero) - tableroPosibles[c3][c4]=0 + #tableroPosibles = tablero[:] + tableroPosibles = [[0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0]] + + for y in range(8): + for x in range(8): + tableroPosibles[y][x] = Casilla(0,0, chr(65+y)+str(x+1),False) + + tableroPosibles[y][x].color = tablero[y][x].color + + tableroPosibles[y][x].tipo = tablero[y][x].tipo + + tableroPosibles[y][x].vacia = tablero[y][x].vacia + + + tableroPosibles[c3][c4].vacia = True #Comprueba que "posibles" no sea igual que en la anterior pasaad while (posibles != posiblesCopia): @@ -356,7 +335,7 @@ def calcularPosibles(c3,c4): #Si encuentra una ficha del mismo color que el de la que está comiendo, deja de comprobar en esa direccion. try: - if tableroPosibles[valor1+x+superX][valor2+y+superY] != 0 and tablero[c3][c4].color == tableroPosibles[valor1+x+superX][valor2+y+superY].color: + if tableroPosibles[valor1+x+superX][valor2+y+superY].vacia == False and tablero[c3][c4].color == tableroPosibles[valor1+x+superX][valor2+y+superY].color: break except IndexError: break @@ -373,13 +352,14 @@ def calcularPosibles(c3,c4): return posibles + def addPosibles(valor1,valor2, x,y, lista,posibles, superX, superY,tableroPosibles): if (valor1 >= 0) and (valor2 >= 0): #Captura el caso de comprobar una casilla fuera del rango de la lista try: #En el caso de que cumpla las condicciones para que la posición pueda ser comida también comprueba - if (tableroPosibles[valor1+x+superX][valor2+y+superY] != 0) and (tableroPosibles[valor1+(2*x+superX)][valor2+(2*y+superY)] == 0) and (tableroPosibles[valor1+x+superX][valor2+y+superY].color != turnoColor): + if (tableroPosibles[valor1+x+superX][valor2+y+superY].vacia == False) and (tableroPosibles[valor1+(2*x+superX)][valor2+(2*y+superY)].vacia == True) and (tableroPosibles[valor1+x+superX][valor2+y+superY].color != turnoColor): if (valor1+2*x+superX >= 0) and (valor2+2*y+superY >= 0): @@ -454,8 +434,7 @@ def numFichas(turnoColor): #Controla la continuidad de la aplicacion. while seguir == True: - tableroAnterior = copy.deepcopy(tablero) - jugadas.append(tableroAnterior) + jugadas.append(tablero) verTablero() diff --git a/Damas.pyc b/Damas.pyc new file mode 100644 index 0000000..dbf9620 Binary files /dev/null and b/Damas.pyc differ diff --git a/Ficha.py b/Ficha.py index d16c73d..50375fe 100644 --- a/Ficha.py +++ b/Ficha.py @@ -1,29 +1,79 @@ -class Ficha: - """ Clase Ficha de la que se van a crear objetos """ - """ Cada objeto Ficha representa un peon o dama del tablero colocados en una posicion del mismo.""" +#Adrian Calvo Rojo y Sergio Garcia Prado +#!/usr/bin/python +from gi.repository import Gtk + +class Casilla(Gtk.Button): #Inicializar cada objeto - def __init__(self, color, posicion, tipo): + def __init__(self, color, tipo, posicion, vacia): + super(Casilla, self).__init__() + super(Casilla, self).set_size_request(75,75) + #Las fichas negras = 0 y las blancas = 1 self.color = color - - self.posicion = posicion #Las fichas = 0 y las damas = 1 self.tipo = tipo + self.posicion = posicion - #Funcion que devuelve las fichas para ser impresas - def verFicha(self): + self.seleccionado = False - if self.color == 0: - if self.tipo == 0: - return "*" - else: - return "X" + self.vacia = vacia + + if vacia: + super(Casilla, self).set_name('Vacia') + else: + if color == 0: + if tipo == 0: + super(Casilla, self).set_name('FichaNegra') + else: + super(Casilla, self).set_name('FichaNegraDama') + if color == 1: + if tipo == 0: + super(Casilla, self).set_name('FichaBlanca') + else: + super(Casilla, self).set_name('FichaBlancaDama') + + def setVacia(self): + self.set_name('Vacia') + self.vacia = True + + def mov(self, Casilla): + + Casilla.color = self.color + Casilla.tipo = self.tipo + Casilla.set_name(self.get_name()) + self.setVacia() + Casilla.vacia = False + Casilla.posicion = self.posicion + Casilla.reset() + + + def reset(self): + self.seleccionado = False + if not self.vacia: + if self.color == 0: + if self.tipo == 0: + self.set_name('FichaNegra') + else: + self.set_name('FichaNegraDama') + if self.color == 1: + if self.tipo == 0: + self.set_name('FichaBlanca') + else: + self.set_name('FichaBlancaDama') + + def ver(self): + + if self.vacia: + ver = "Vacia" else: - if self.tipo == 0: - return "o" + ver = self.posicion + if self.color == 1: + ver += ", Blanca" else: - return "8" \ No newline at end of file + ver += ", Negra" + + print ver \ No newline at end of file diff --git a/Ficha.pyc b/Ficha.pyc index 4748b07..53cb684 100644 Binary files a/Ficha.pyc and b/Ficha.pyc differ diff --git a/Images/Blanca60.png b/Images/Blanca60.png new file mode 100644 index 0000000..f42dfd8 Binary files /dev/null and b/Images/Blanca60.png differ diff --git a/Images/Negra60.png b/Images/Negra60.png new file mode 100644 index 0000000..a9d6423 Binary files /dev/null and b/Images/Negra60.png differ diff --git a/Images/fichaBlanca.png b/Images/fichaBlanca.png new file mode 100644 index 0000000..dffcfd8 Binary files /dev/null and b/Images/fichaBlanca.png differ diff --git a/Ventana.py b/Ventana.py new file mode 100644 index 0000000..9f9a1f3 --- /dev/null +++ b/Ventana.py @@ -0,0 +1,436 @@ +#!/usr/bin/python +from gi.repository import Gtk, Gdk +from Ficha import Casilla + +#Movimiento que se va a realizar al hacer click en dos casillas +mueveme = "" + +#Variable que guarda todas las jugadas +listaJugadas = [] + +#Indica si el juego debe continuar o no +seguir = True + +#Esta variable indica si se mueven las fichas blancas o las negras (Blancas = True , Negras =False) turnoColor hace lo mismo, solo que con 0 y 1 respectivamente +turno = "Blancas" +turnoColor = 0 + +#Carga un fichero con movimientos desde un archivo de texto con el nombre introducido por el usuario +#fichero = str(raw_input(" Indique el fichero desde el que se carga la partida: ")) + ".txt" +fich = "" +""" +try: + fich = open("partidas/" + fichero, "r") +except IOError: + + print "\n No existe un fichero con ese nombre.\n" + fich = "" +""" + +#### Funciones #### + +def selecionarMovi(casilla, posicion): + + global mueveme, turno, turnoColor + + if casilla.color == 0 and not casilla.vacia: + casilla.set_name("FichaNegraSel") + casilla.seleccionado = True + if casilla.color == 1 and not casilla.vacia: + casilla.set_name("FichaBlancaSel") + casilla.seleccionado = True + + + mueveme += posicion + if len(mueveme) == 4: + print mueveme + + #Lee la siguiente linea del fichero, en el caso de que este vacia o no se haya introducido fichero, pide por teclado el movimiento + if fich != "": + cad = fich.readline(4) + fich.readline() + if cad != "": + movimiento = cad + else: + movimiento = mueveme + + movimiento = mueveme + + if entradaPermitida(movimiento) == True: + + #Conmuta el turno de cada color, y muestra en pantalla a quien le toca + if turno == "Negras": + turno = "Blancas" + turnoColor = 1 + else: + turno = "Negras" + turnoColor = 0 + print " Turno de las " + turno + + #Divide el movimiento en las componentes de las coordenadas origen y destino + + c1 = ord(movimiento[0]) - 65 + c2 = int(movimiento[1])-1 + c3 = ord(movimiento[2]) - 65 + c4 = int(movimiento[3])-1 + + #es quien elige el tipo de movimiento(mover o comer) + puedeMover(c1, c2, c3, c4) + + listaJugadas.append(mueveme) + mueveme = "" + print listaJugadas + + for aa in range(8): + for bb in range(8): + if tablero[aa][bb].seleccionado: + tablero[aa][bb].reset() + +""" +def hover(casilla, posicion): + print posicion +""" + +#Comprueba si la entrada del usuario es valida +def entradaPermitida(movimiento): + + c1 = ord(movimiento[0]) - 65 + c2 = int(movimiento[1]) - 1 + c3 = ord(movimiento[2]) - 65 + c4 = int(movimiento[3]) - 1 + + #Comprueba si la orden esta compuesta por 4 caracteres + longitud = len(movimiento) + if longitud != 4: + print " Fallo: Debe introducir 4 caracteres. \n" + return False + + #Buscamos que el movimiento sea solo en las casillas blancas + if (abs(c3) - c4+1) % 2 != 0: + + print " Solo se puede mover en las casillas blancas. \n" + return False + + #Comprobamos si el movimiento es solo en diagonal + if abs(c1 - c3) != abs(c2 - c4): + + print " Solo se puede mover en diagonal. \n" + return False + + + #Comprueba que el movimiento de los peones solo es de una unidad + if (tablero[c1][c2].tipo == 0) and calcularDistancia(c1, c3) != 1: + + print " Los peones solo se pueden mover con distancia 1. \n" + return False + + #Comprueba que no se haya movido la ficha del jugador rival + if ((tablero [c1][c2].color == 0) and (turno == "Blancas")) or ((tablero [c1][c2].color == 1) and (turno == "Negras")): + + print " No puede mover las fichas del jugador contrario. Tramposo!! \n" + return False + + #Comprueba que la ficha que se quiere comer no sea del mismo color que la que come. + if (tablero[c3][c4].vacia == False) and (tablero[c1][c2].color == tablero[c3][c4].color): + print " No se pueden comer fichas propias. \n" + return False + + #Calculamos la distancia y la direccion de las coordenadas (x, y) + distancia = calcularDistancia(c1, c3) + x,y = direcMovimiento(c1, c2, c3, c4) + + #Comprueba que las reinas no salten ningun peon + if (tablero[c1][c2].tipo == 1) and (distancia != 1): + + i = 1 + while (i != distancia): + + lado = i * x + arriba = i * y + i += 1 + + if tablero[c1 + lado][c2 + arriba].vacia == False: + print " Las reinas no pueden saltar peones. \n" + return False + + #En caso de que no se cumpla ningun caso anterior, quiere decir que la entrada del usuario ha sido correcta, por lo que devuelve verdadero + return True + + +#Devuelve la distancia del movimiento realizado +def calcularDistancia(c1, c3): + return abs(c1 - c3) + +#Funcion que indica si el movimiento es comiendo o sin comer una ficha +def puedeMover(c1, c2, c3, c4): + + global seguir + + #si la posicion a la que se mueve esta vacia llama a mover, sino llama a comerficha + if tablero[c3][c4].vacia == True: + mover(c1, c2, c3, c4) + + else: + + #comprueba que las fichas son de distinto color + if (tablero[c3][c4].color != tablero[c1][c2].color): + + x,y = direcMovimiento(c1, c2, c3, c4) + + #llama a comerficha si la posicion siguiente esta vacia si salta un error es porque la ficha se colocaria fuera del tablero, en cuyo caso se captura + try: + if (c4 != 0) and (tablero[c3 + x][c4 + y].vacia == True): + + comerFicha(c1, c2, c3, c4) + comerEnCadena(c3 + x,c4 + y) + + else: + print "Movimiento no valido. Ficha fuera de tablero o casilla ocupada" + seguir = False + except IndexError: + print "Movimiento no valido. Ficha fuera de tablero" + seguir = False + +#Devuelve la direccion del movimiento en dos variables separadas, la "x" son el eje vertical y la "y" el horizontal +def direcMovimiento(c1, c2, c3, c4): + + x = (c3 - c1)/calcularDistancia(c1, c3) + y = (c4 - c2)/calcularDistancia(c1, c3) + + return x,y + +#Funcion que mueve la ficha +def mover(c1, c2, c3, c4): + + #Pasamos la antigua ficha a la nueva posicion + + tablero[c1][c2].mov(tablero[c3][c4]) + promociona(c3, c4) + +#funcion que mueve la ficha a la posicion siguiente de la indicada y elimina la ficha de la posicion marcada, es decir, la come- +def comerFicha(c1, c2, c3, c4): + + x,y = direcMovimiento(c1, c2, c3, c4) + + #Pasamos la antigua ficha a la nueva posicion + tablero[c1][c2].mov(tablero[c3 + x][c4 + y]) + + #Borramos la posicion antigua y la de la ficha que se ha comido + tablero[c3][c4].setVacia() + + promociona(c3 + x, c4 + y) + +#funcion que es llamada despues de comer una ficha, come el mayor numero de fichas posibles automaticamente +def comerEnCadena(c3,c4): + + #posibles es una lista que almacena todas las posibles combinaciones de movimientos que se pueden dar. Para calcular los posibles movimientos se llama a calcularPosibles + posibles = [] + posibles = calcularPosibles(c3,c4) + + #En el caso de que haya alguna combinacion de movimientos, se elige el mas largo de todos y se guarda en posibles. + if len(posibles) > 0: + + a = len(posibles[0]) + movimientos = posibles[0] + + for i in posibles: + b = len(i) + + if (a <= b): + movimientos = i + a = b + + #Se inicializan caracter 1 y 2 con los valores de caracter 3 y 4 respectivamente. + distancia = len(movimientos) + c1=c3 + c2=c4 + + #se recorre la lista que guarda la combinacion movimientos mientras se va llamando a comerFicha cada vez, caracter 3 y 4 son los valores de la lista, mientras que caracter 1 y 2 son la casilla siguiente a estos en el ciclo anterior. + for recorrido in range(distancia): + + c3 = int(movimientos[recorrido][0]) + c4 = int(movimientos[recorrido][1]) + + comerFicha(c1,c2,c3,c4) + + x,y = direcMovimiento(c1, c2, c3, c4) + c1 = c3 + x + c2 = c4 + y + +#Funcion que convierte en reina a una ficha cuando llega a la primera linea del color contrario. +def promociona(c3, c4): + if ((tablero[c3][c4].color == 0) and c3 == 7) or ((tablero[c3][c4].color == 1) and c3 == 0): + + tablero[c3][c4].tipo = 1 + +#Funcion que devuelve la lista de los posibles movimientos que puede hacer la ficha. +def calcularPosibles(c3,c4): + #Creamos posibles y posibles copia, "posibles" sera donde se almacenaran los posibles movimientos, "posiblesCopia" sirve para que si no ha cambiado nada en la siguiente iteracion termine de buscar posibilidades, ya que no hay mas. + posibles = [] + posiblesCopia = [] + + #Es el primer valor, y desde donde se empezaran a analizar las posibles opciones. + original = str(c3) + str(c4) + posibles.append([original]) + #tableroPosibles = tablero[:] + tableroPosibles = [[0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0]] + + for y in range(8): + for x in range(8): + tableroPosibles[y][x] = Casilla(0,0, chr(65+y)+str(x+1),False) + + tableroPosibles[y][x].color = tablero[y][x].color + + tableroPosibles[y][x].tipo = tablero[y][x].tipo + + tableroPosibles[y][x].vacia = tablero[y][x].vacia + + + tableroPosibles[c3][c4].vacia = True + + #Comprueba que "posibles" no sea igual que en la anterior pasaad + while (posibles != posiblesCopia): + posiblesCopia = posibles[:] + + #Recorre las cuatro direcciones + for x in range (1,-2,-2): + for y in range(1,-2,-2): + + #Recorre cada una de las posibilidades (listas dentro de posibles) + for i in posibles: + + #Copia la iteracion en lista, y extrae el ultimo valor en "lista1" y "lista2" y si estos son mayores que 0 sigue con el flujo del programa. + lista = i[:] + valor = lista.pop() + valor1 = int(valor[0]) + valor2 = int(valor[1]) + + #Recorre todos los movimientos + for r in i: + + #Si encuentra que una ficha es o se ha transformado en reina, recorre la diagonal, sino solo mira la posicion siguiente. + if (turnoColor != 1 and r[0] == "1") or (turnoColor != 0 and r[0] == "6") or (tablero[c3][c4].tipo == 1): + + for j in range(5): + superX = x * j + superY = y * j + + #Si encuentra una ficha del mismo color que el de la que esta comiendo, deja de comprobar en esa direccion. + try: + if tableroPosibles[valor1+x+superX][valor2+y+superY].vacia == False and tablero[c3][c4].color == tableroPosibles[valor1+x+superX][valor2+y+superY].color: + break + except IndexError: + break + + + addPosibles(valor1,valor2, x,y, lista,posibles, superX, superY, tableroPosibles) + + else: + addPosibles(valor1,valor2, x,y, lista,posibles, 0, 0, tableroPosibles) + + + #Elimina el ultimo valor de cada una de las listas de movimientos dentro de posibles, ya que este es "sig", es decir, la proxima casilla a analizar(que en este caso no hay) + for sigDelete in posibles: + sigDelete.pop() + print posibles + + return posibles + +def addPosibles(valor1,valor2, x,y, lista,posibles, superX, superY,tableroPosibles): + if (valor1 >= 0) and (valor2 >= 0): + + #Captura el caso de comprobar una casilla fuera del rango de la lista + try: + + #En el caso de que cumpla las condicciones para que la posicion pueda ser comida tambien comprueba + if (tableroPosibles[valor1+x+superX][valor2+y+superY].vacia == False) and (tableroPosibles[valor1+(2*x+superX)][valor2+(2*y+superY)].vacia == True) and (tableroPosibles[valor1+x+superX][valor2+y+superY].color == turnoColor): + + if (valor1+2*x+superX >= 0) and (valor2+2*y+superY >= 0): + + #"movi" es el valor que se usara para comer la ficha mientras que "sig" es la casilla siguiente que se comprobara(despues de usarse queda eliminado de la lista) + movi = str(valor1+x+superX)+ str (valor2+y+superY) + sig = str(valor1+(2*x+superX))+ str (valor2+(2*y+superY)) + + + #si "movi" no pertenece a la lista de movimientos, se anaden + if (perteneceALista(movi, lista) == False): + lista.append(movi) + lista.append(sig) + + #Si ya hay una lista con los mismos valores dentro de posibles, esta se descarta, sino, se anade. + if (perteneceALista(lista, posibles) == False): + posibles.append(lista) + + except IndexError: + pass + + return posibles + +#Funcion booleana, si el primer parametro pertenece al segundo parametro. +def perteneceALista(movi, posibles): + try: + posibles.index(movi) + return True + + except ValueError: + return False + +#Funcion que devuelve las fichas que quedan del color que se indica. +def numFichas(turnoColor): + fichas = 0 + + #Recorre la lista y va incrementando "fichas" por cada ficha del jugador contrario que se encuentra + for x in range(8): + for y in range (8): + if tablero[x][y] != 0: + if turnoColor != tablero[x][y].color: + fichas = fichas + 1 + + return fichas + +#Ventana Gtk.WindowType.TOPLEVEL, Gtk.WindowType.POPUP +win = Gtk.Window(title = "Damas - Python", name = "Ventana") +ancho = 640 +alto = 640 +win.set_default_size(1024, alto) + +tablero = [[0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0]] + +#Layout Fixed con distancias en pixeles +fix = Gtk.Fixed() + +#Disponer las casillas vacias y con fichas en el tablero +for a in range(8): + for b in range(8): + if (a == 0 or a == 1 or a == 2) and ((a-b)%2 != 0): + tablero[a][b] = Casilla(0,0, chr(65+a)+str(b+1),False) + elif (a == 5 or a == 6 or a == 7) and ((a-b)%2 != 0): + tablero[a][b] = Casilla(1,0, chr(65+a)+str(b+1),False) + else: + tablero[a][b] = Casilla(0,0, chr(65+a)+str(b+1),True) + #Dar los eventos a cada casilla + tablero[a][b].connect("clicked", selecionarMovi, tablero[a][b].posicion) + #tablero[a][b].connect("enter", hover, tablero[a][b].posicion) + +#Colocar las casillas dentro del Fixed +for x in range(-7,1): + for y in range(8): + fix.put(tablero[abs(x)][abs(y)], (alto/8*abs(y))+5, (ancho/8*(7-abs(x)))+5) + +#Anadir el Fixed a la ventana +win.add(fix) + +#Evento de cerrar al cerrar la ventana +win.connect("delete-event", Gtk.main_quit) + +#Cargar estilos de un fichero +style_provider = Gtk.CssProvider() + +css = open('css/estilo.css', 'rb') +css_data = css.read() +css.close() + +style_provider.load_from_data(css_data) +Gtk.StyleContext.add_provider_for_screen(Gdk.Screen.get_default(), style_provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION) +win.show_all() +Gtk.main() \ No newline at end of file diff --git a/css/estilo.css b/css/estilo.css new file mode 100644 index 0000000..a1daa15 --- /dev/null +++ b/css/estilo.css @@ -0,0 +1,41 @@ +#Ventana{ + background-color: #2A2A2A; + background-repeat: no-repeat; + background-image: url('Images/tablero_idea.png') +} +#FichaBlanca{ + background-image: url('Images/Blanca60.png'); + background-repeat: no-repeat; + background-position: center; + border: none; + background-color: rgba(0,0,0,0); +} +#FichaBlancaSel{ + background-image: url('Images/Blanca60.png'); + background-repeat: no-repeat; + background-position: center; + border: 2px double yellow; + background-color: rgba(0,0,0,0); +} +#FichaNegra{ + background-image: url('Images/Negra60.png'); + background-repeat: no-repeat; + background-position: center; + border: none; + background-color: rgba(0,0,0,0); +} +#FichaNegraSel{ + background-image: url('Images/Negra60.png'); + background-repeat: no-repeat; + background-position: center; + border: 2px double yellow; + border-radius: 30px; + background-color: rgba(0,0,0,0); +} +#Vacia{ + background-image: none; + background-repeat: no-repeat; + background-position: center; + border: none; + background-color: rgba(0,0,0,0); +} \ No newline at end of file diff --git a/partidas/default.txt b/partidas/default.txt index 17f2ff7..e69de29 100644 --- a/partidas/default.txt +++ b/partidas/default.txt @@ -1,47 +0,0 @@ -F3E4 -C2D3 -G2F3 -B1C2 -F5E6 -D3E4 -F3E4 -C4D5 -H3G2 -D5E4 -F7E6 -D7E6 -G6F7 -B3C4 -F7E8 -C6D7 -E8D7 -B7C6 -G2F3 -B5C6 -H1G2 -A8B7 -G8F7 -D7E6 -G2F3 -E6F7 -H5G6 -C8D7 -G6F5 -D7E6 -F5E6 -C4D5 -D7E6 -B7C6 -F3E4 -A4B5 -E6F5 -G8F7 -F5G6 -C6D7 -F1G2 -A6B7 -G2H1 -C2B3 -G6H5 -H3F5 -E4D5