from Movimiento import Movimiento
from Mensajes import Mensajes
class Tablero:
def __init__(self, xdimensiones, xcaracteres):
self.__dimensiones = xdimensiones
self.__caracteres = xcaracteres
self.__ESPACIOENBLANCO = "_"
self.__tamanio = self.__dimensiones * self.__dimensiones
self.__cuadrados = self.__cargarTablero()
self.__ganandoFilas = self.__cargarFilas()
self.__ganandoFilas = self.__configuracionPopularGanadora(self.__ganandoFilas)
self.__ganandoDiag = self.__configuracionPopularDiagonal()
def __cargarTablero(self):
self.__cuadrados = []
for i in range(0, self.__tamanio + 1):
self.__cuadrados.append(self.__ESPACIOENBLANCO)
return self.__cuadrados
def __cargarFilas(self):
self.__ganandoFilas = []
for i in range(0, self.__dimensiones):
aux = []
for j in range(0, self.__dimensiones):
aux.append(0)
self.__ganandoFilas.append(aux)
return self.__ganandoFilas
def getCuadrado(self):
return self.__cuadrados
def mostrar(self):
res = ""
for i in range(0, self.__tamanio):
res += " " + cuadrados[i] + " "
if i % self.__dimensiones != 0:
res += "|"
elif i % tamanio != 0:
res += "\n"
boardWidth = 4 * self.__dimensiones - 1
for j in range(0, boardWidth):
res += "-"
res += "\n"
res += "\n"
return res
def aplicarMarcador(self, posicion, marcador):
if posicion < 1 or posicion > self.__tamanio:
Mensajes.messageInfo("Por favor escoja una posición entre el 1 y 9.")
return Movimiento.FUERADERANGO
elif self.__cuadrados[posicion] != self.__ESPACIOENBLANCO:
return Movimiento.ESPACIOTOMADO
else:
self.__cuadrados[posicion] = marcador
return Movimiento.EXITO
def __limpiarEspacio(self, posicion):
if posicion < 1 or posicion > self.__tamanio:
Mensajes.messageInfo("Por favor escoja una posición entre el 1 y 9.")
return Movimiento.FUERADERANGO
else:
self.__cuadrados[posicion] = self.__ESPACIOENBLANCO
return Movimiento.EXITO
def configuracionGanadora(self):
return (
self.__verificarLineas(self.__ganandoFilas) is True
or self.__verificarLineas(self.__transponer(self.__ganandoFilas)) is True
or self.__verificarLineas(self.__ganandoDiag) is True
)
def __verificarLineas(self, lineasGanadoras):
for row in range(0, len(lineasGanadoras)):
linea = self.__obtenerPorIndice(lineasGanadoras[row])
if self.__contieneCaracter(linea, self.__ESPACIOENBLANCO) is False:
bandera = True
primero = linea[0]
i = 1
while i < len(linea) and bendera is True:
if linea[i] != primero:
bandera = False
i += 1
if bandera is True:
return True
return False
def __obtenerPorIndice(self, indices):
outArr = []
for i in range(0, len(indices)):
outArr.append(self.__cuadrados[indices[i]])
return outArr
def __contieneCaracter(self, array, key):
for i in range(0, len(array)):
if array[i] == key:
return True
return False
def __configuracionPopularGanadora(self, matrix):
value = 1
for row in range(0, len(matrix)):
for col in range(0, len(matrix)):
matrix[row][col] = value
value += 1
return matrix
def __configuracionPopularDiagonal(self):
matrix = []
for i in range(0, 2):
aux = []
for n in range(0, self.__dimensiones):
aux.append(1 + n * (self.__dimensiones + 1))
aux.append(self.__dimensiones + n * (self.__dimensiones - 1))
matrix.append(aux)
return matrix
def __transponer(self, matrix):
for i in range(0, len(matrix)):
for j in range(0, i):
temp = matrix[i][j]
matrix[i][j] = matrix[j][i]
matrix[j][i] = temp
return matrix
def encontrarEspacioGanador(self, playerChar):
for index in range(1, len(self.__tamanio), +1):
if self.aplicarMarcador(index, playerChar) is Movimiento.EXITO:
# Averigüe si la aplicación de ese personaje ganó el TATETI
ganadorIntroducido = self.configuracionGanadora()
# Asegúrese de deshacer el movimiento antes de regresar
self.__limpiarEspacio(index)
# Si esto es verdadero, entonces esto es el espacio ganador
if ganadorIntroducido is True:
return index
return -1
def encontrandoNumeroEspaciosGanadores(self, caracter):
"""
La forma en que esto funciona es que simplemente aplicamos este
caracter del jugador a cada espacio abierto para ver si hay un
movimiento que le da a este jugador la victoria. Si encontramos
uno ese es el índice que devolvemos
"""
numEspaciosGanadores = 0
for index in range(1, len(self.__tamanio), +1):
if self.aplicarMarcador(index, playerChar) is Movimiento.EXITO:
# Averigüe si la aplicación de ese personaje ganó el TATETI
ganadorIntroducido = self.configuracionGanadora()
# Asegúrese de deshacer el movimiento antes de regresar
self.__limpiarEspacio(index)
# Si esto es verdadero, entonces esto es el espacio ganador
if ganadorIntroducido is True:
numEspaciosGanadores += 1
return numEspaciosGanadores
def encontrarEspacioDeBloqueo(self, caracter):
otroCaracter = self.__encontrarOtroJugador(caracter)
return encontrarEspacioGanador(otroCaracter)
def encontrarBifurcacionEnEspacio(self, caracter):
"""
Básicamente, simplemente recorremos todos los cuadrados y si poner
una marca en cualquier cuadrado introduce dos configuraciones ganadoras,
entonces tenemos una bifurcación y devolvemos el índice del cuadrado
"""
for index in range(1, len(self.__tamanio), +1):
if self.aplicarMarcador(index, caracter) is Movimiento.EXITO:
# Averigüe si la aplicación de ese personaje ganó el TATETI
numEspaciosGanadores = self.encontrandoNumeroEspaciosGanadores(caracter)
# Asegúrese de deshacer el movimiento antes de regresar
self.__limpiarEspacio(index)
# Si esto es verdadero, entonces esto es el espacio ganador
if numEspaciosGanadores > 1:
return index
return -1
def encontrarEspacioCentralAbierto(self):
centerIndex = self.__tamanio / 2
if self.__cuadrados[centerIndex] == self.__ESPACIOENBLANCO:
return centerIndex
else:
return -1
def encontrarEspacioDeEsquinaAbierto(self):
# Siempre tendremos 4 esquinas definidas como tales:
corners = [1, dimensiones, dimensiones * dimensiones - (dimensiones - 1), dimensiones * dimensiones]
for corner in corners:
if self.__cuadrados[corner] == self.__ESPACIOENBLANCO:
return corner
return -1
# Hace una lista de espacios laterales, devuelve uno si está abierto
def encontrarEspacioLateralVacio(self):
# TODO: Generalice esto a más de 3x3 cuadrícula
lados = [2, 4, 6, 8]
for lado in lados:
if self.__cuadrados[lado] == self.__ESPACIOENBLANCO:
return lado
return -1
def __encontrarOtroJugador(self, caracter):
for i in range(0, len(self.__caracteres)):
if self.__caracteres[i] != caracter:
return self.__caracteres[i]
# Si no podemos encontrarlo, devuelve el carácter nulo
return "\u0000"