Foros del Web » Programando para Internet » Python »

[SOLUCIONADO] TATETI en Python

Estas en el tema de TATETI en Python en el foro de Python en Foros del Web. Hola a todos, quería preguntarles lo siguiente, resulta que tengo un código del tateti hecho en Java y lo traducí a Python pero cuando ejecuto ...
  #1 (permalink)  
Antiguo 07/10/2019, 12:47
Avatar de detective_jd  
Fecha de Ingreso: abril-2011
Ubicación: Salto
Mensajes: 424
Antigüedad: 8 años, 6 meses
Puntos: 6
TATETI en Python

Hola a todos, quería preguntarles lo siguiente, resulta que tengo un código del tateti hecho en Java y lo traducí a Python pero cuando ejecuto el código funciona sólo hasta la parte de selección del modo de juego y después queda cómo en un bucle infinito, pongo el código:

Código Python:
Ver original
  1. from Movimiento import Movimiento
  2. from Mensajes import Mensajes
  3. class Tablero:
  4.     def __init__(self, xdimensiones, xcaracteres):
  5.         self.__dimensiones = xdimensiones
  6.         self.__caracteres = xcaracteres
  7.         self.__ESPACIOENBLANCO = "_"
  8.         self.__tamanio = self.__dimensiones * self.__dimensiones
  9.         self.__cuadrados = self.__cargarTablero()
  10.         self.__ganandoFilas = self.__cargarFilas()
  11.         self.__ganandoFilas = self.__configuracionPopularGanadora(self.__ganandoFilas)
  12.         self.__ganandoDiag = self.__configuracionPopularDiagonal()
  13.  
  14.     def __cargarTablero(self):
  15.         self.__cuadrados = []
  16.         for i in range(0, self.__tamanio + 1):
  17.             self.__cuadrados.append(self.__ESPACIOENBLANCO)
  18.         return self.__cuadrados
  19.  
  20.     def __cargarFilas(self):
  21.         self.__ganandoFilas = []
  22.         for i in range(0, self.__dimensiones):
  23.             aux = []
  24.             for j in range(0, self.__dimensiones):
  25.                 aux.append(0)
  26.             self.__ganandoFilas.append(aux)
  27.         return self.__ganandoFilas
  28.  
  29.     def getCuadrado(self):
  30.         return self.__cuadrados
  31.  
  32.     def mostrar(self):
  33.         res = ""
  34.         for i in range(0, self.__tamanio):
  35.             res += " " + cuadrados[i] + " "
  36.             if i % self.__dimensiones != 0:
  37.                 res += "|"
  38.             elif i % tamanio != 0:
  39.                 res += "\n"
  40.                 boardWidth = 4 * self.__dimensiones - 1
  41.                 for j in range(0, boardWidth):
  42.                     res += "-"
  43.                 res += "\n"
  44.         res += "\n"
  45.         return res
  46.  
  47.     def aplicarMarcador(self, posicion, marcador):
  48.         if posicion < 1 or posicion > self.__tamanio:
  49.             Mensajes.messageInfo("Por favor escoja una posición entre el 1 y 9.")
  50.             return Movimiento.FUERADERANGO
  51.         elif self.__cuadrados[posicion] != self.__ESPACIOENBLANCO:
  52.             return Movimiento.ESPACIOTOMADO
  53.         else:
  54.             self.__cuadrados[posicion] = marcador
  55.             return Movimiento.EXITO
  56.  
  57.     def __limpiarEspacio(self, posicion):
  58.         if posicion < 1 or posicion > self.__tamanio:
  59.             Mensajes.messageInfo("Por favor escoja una posición entre el 1 y 9.")
  60.             return Movimiento.FUERADERANGO
  61.         else:
  62.             self.__cuadrados[posicion] = self.__ESPACIOENBLANCO
  63.             return Movimiento.EXITO
  64.  
  65.     def configuracionGanadora(self):
  66.         return (
  67.             self.__verificarLineas(self.__ganandoFilas) is True
  68.             or self.__verificarLineas(self.__transponer(self.__ganandoFilas)) is True
  69.             or self.__verificarLineas(self.__ganandoDiag) is True
  70.         )
  71.  
  72.     def __verificarLineas(self, lineasGanadoras):
  73.         for row in range(0, len(lineasGanadoras)):
  74.             linea = self.__obtenerPorIndice(lineasGanadoras[row])
  75.             if self.__contieneCaracter(linea, self.__ESPACIOENBLANCO) is False:
  76.                 bandera = True
  77.                 primero = linea[0]
  78.                 i = 1
  79.                 while i < len(linea) and bendera is True:
  80.                     if linea[i] != primero:
  81.                         bandera = False
  82.                     i += 1
  83.                 if bandera is True:
  84.                     return True
  85.         return False
  86.  
  87.     def __obtenerPorIndice(self, indices):
  88.         outArr = []
  89.         for i in range(0, len(indices)):
  90.             outArr.append(self.__cuadrados[indices[i]])
  91.         return outArr
  92.  
  93.     def __contieneCaracter(self, array, key):
  94.         for i in range(0, len(array)):
  95.             if array[i] == key:
  96.                 return True
  97.         return False
  98.  
  99.     def __configuracionPopularGanadora(self, matrix):
  100.         value = 1
  101.         for row in range(0, len(matrix)):
  102.             for col in range(0, len(matrix)):
  103.                 matrix[row][col] = value
  104.                 value += 1
  105.         return matrix
  106.  
  107.     def __configuracionPopularDiagonal(self):
  108.         matrix = []
  109.         for i in range(0, 2):
  110.             aux = []
  111.             for n in range(0, self.__dimensiones):
  112.                 aux.append(1 + n * (self.__dimensiones + 1))
  113.                 aux.append(self.__dimensiones + n * (self.__dimensiones - 1))
  114.             matrix.append(aux)
  115.         return matrix
  116.  
  117.     def __transponer(self, matrix):
  118.         for i in range(0, len(matrix)):
  119.             for j in range(0, i):
  120.                 temp = matrix[i][j]
  121.                 matrix[i][j] = matrix[j][i]
  122.                 matrix[j][i] = temp
  123.         return matrix
  124.  
  125.     def encontrarEspacioGanador(self, playerChar):
  126.         for index in range(1, len(self.__tamanio), +1):
  127.             if self.aplicarMarcador(index, playerChar) is Movimiento.EXITO:
  128.                 # Averigüe si la aplicación de ese personaje ganó el TATETI
  129.                 ganadorIntroducido = self.configuracionGanadora()
  130.                 # Asegúrese de deshacer el movimiento antes de regresar
  131.                 self.__limpiarEspacio(index)
  132.                 # Si esto es verdadero, entonces esto es el espacio ganador
  133.                 if ganadorIntroducido is True:
  134.                     return index
  135.         return -1
  136.  
  137.     def encontrandoNumeroEspaciosGanadores(self, caracter):
  138.         """
  139.            La forma en que esto funciona es que simplemente aplicamos este
  140.            caracter del jugador a cada espacio abierto para ver si hay un
  141.            movimiento que le da a este jugador la victoria. Si encontramos
  142.            uno ese es el índice que devolvemos
  143.        """
  144.         numEspaciosGanadores = 0
  145.         for index in range(1, len(self.__tamanio), +1):
  146.             if self.aplicarMarcador(index, playerChar) is Movimiento.EXITO:
  147.                 # Averigüe si la aplicación de ese personaje ganó el TATETI
  148.                 ganadorIntroducido = self.configuracionGanadora()
  149.                 # Asegúrese de deshacer el movimiento antes de regresar
  150.                 self.__limpiarEspacio(index)
  151.                 # Si esto es verdadero, entonces esto es el espacio ganador
  152.                 if ganadorIntroducido is True:
  153.                     numEspaciosGanadores += 1
  154.         return numEspaciosGanadores
  155.  
  156.     def encontrarEspacioDeBloqueo(self, caracter):
  157.         otroCaracter = self.__encontrarOtroJugador(caracter)
  158.         return encontrarEspacioGanador(otroCaracter)
  159.  
  160.     def encontrarBifurcacionEnEspacio(self, caracter):
  161.         """
  162.            Básicamente, simplemente recorremos todos los cuadrados y si poner
  163.            una marca en cualquier cuadrado introduce dos configuraciones ganadoras,
  164.            entonces tenemos una bifurcación y devolvemos el índice del cuadrado
  165.        """
  166.         for index in range(1, len(self.__tamanio), +1):
  167.             if self.aplicarMarcador(index, caracter) is Movimiento.EXITO:
  168.                 # Averigüe si la aplicación de ese personaje ganó el TATETI
  169.                 numEspaciosGanadores = self.encontrandoNumeroEspaciosGanadores(caracter)
  170.                 # Asegúrese de deshacer el movimiento antes de regresar
  171.                 self.__limpiarEspacio(index)
  172.                 # Si esto es verdadero, entonces esto es el espacio ganador
  173.                 if numEspaciosGanadores > 1:
  174.                     return index
  175.         return -1
  176.  
  177.     def encontrarEspacioCentralAbierto(self):
  178.         centerIndex = self.__tamanio / 2
  179.         if self.__cuadrados[centerIndex] == self.__ESPACIOENBLANCO:
  180.             return centerIndex
  181.         else:
  182.             return -1
  183.  
  184.     def encontrarEspacioDeEsquinaAbierto(self):
  185.         # Siempre tendremos 4 esquinas definidas como tales:
  186.         corners = [1, dimensiones, dimensiones * dimensiones - (dimensiones - 1), dimensiones * dimensiones]
  187.         for corner in corners:
  188.             if self.__cuadrados[corner] == self.__ESPACIOENBLANCO:
  189.                 return corner
  190.         return -1
  191.  
  192.     # Hace una lista de espacios laterales, devuelve uno si está abierto
  193.     def encontrarEspacioLateralVacio(self):
  194.         # TODO: Generalice esto a más de 3x3 cuadrícula
  195.         lados = [2, 4, 6, 8]
  196.         for lado in lados:
  197.             if self.__cuadrados[lado] == self.__ESPACIOENBLANCO:
  198.                 return lado
  199.         return -1
  200.  
  201.     def __encontrarOtroJugador(self, caracter):
  202.         for i in range(0, len(self.__caracteres)):
  203.             if self.__caracteres[i] != caracter:
  204.                 return self.__caracteres[i]
  205.         # Si no podemos encontrarlo, devuelve el carácter nulo
  206.         return "\u0000"
__________________
Si te interesa, visita mi perfil de Linkedin. Gracias
  #2 (permalink)  
Antiguo 07/10/2019, 12:51
Avatar de detective_jd  
Fecha de Ingreso: abril-2011
Ubicación: Salto
Mensajes: 424
Antigüedad: 8 años, 6 meses
Puntos: 6
Respuesta: TATETI en Python

Código Python:
Ver original
  1. from Humano import Humano
  2. from Computadora import Computadora
  3. from Estado import Estado
  4. from Movimiento import Movimiento
  5. from Tablero import Tablero
  6. from Mensajes import Mensajes
  7.  
  8.  
  9. class Juego:
  10.     def __init__(self):
  11.         j1, j2 = "", ""
  12.         self.__jugadores = []
  13.         opcion = -1
  14.         while opcion < 0 or opcion > 2:
  15.             opcion = Mensajes.requestInt("Elige modo de juego:\n[0. CPU vs CPU] [1. Jug. vs CPU] [2. Jug. vs Jug.]")
  16.             if opcion == 0:
  17.                 self.__jugadores.append(Computadora("HAL1", "o"))
  18.                 self.__jugadores.append(Computadora("HAL2", "x"))
  19.             elif opcion == 1:
  20.                 j1 = Mensajes.requestAlpha("Jugador 1, ingresa tu nombre")
  21.                 self.__jugadores.append(Humano(j1, "o"))
  22.                 self.__jugadores.append(Computadora("HAL", "x"))
  23.             elif opcion == 2:
  24.                 j1 = Mensajes.requestAlpha("Jugador 1, ingresa tu nombre")
  25.                 j2 = Mensajes.requestAlpha("Jugador 2, ingresa tu nombre")
  26.                 self.__jugadores.append(Humano(j1, "o"))
  27.                 self.__jugadores.append(Humano(j2, "x"))
  28.             else:
  29.                 Mensajes.messageInfo("ERROR: el número de usuarios debe incluirse entre 0 y 2")
  30.         caracteres = ["o", "x"]
  31.         self.__tablero = Tablero(3, caracteres)
  32.         self.__estado = Estado.ENCURSO
  33.  
  34.     """
  35.        Contiene el bucle del juego, simplemente alterna jugadores
  36.        hasta que el juego termina
  37.    """
  38.  
  39.     def play(self):
  40.         marcarTurno = 0
  41.         jugadorActual = self.__jugadores[0]
  42.         # Mientras el juego esta arrancando...
  43.         while self.__estado == Estado.ENCURSO:
  44.             # Orquesta la alternancia del jugador mencionada anteriormente
  45.             jugadorActual = self.__jugadores[marcarTurno % 2]
  46.             movimiento = Movimiento.FRACASO
  47.             """
  48.                Bucle de retroalimentación interna que se ejecuta hasta que el
  49.                jugador finaliza con éxito su turno
  50.            """
  51.             while movimiento == Movimiento.EXITO:
  52.                 # Obtiene la elección del movimiento de los jugadores
  53.                 indiceElegido = jugadorActual.hacerMovimiento(tablero)
  54.                 # Intentos de hacer movimiento
  55.                 movimiento = self.__tablero.aplicarMarcador(indiceElegido, jugadorActual.getCaracter())
  56.                 # Imprime el tablero después de cada turno.
  57.                 Mensajes.messageInfo(tablero.mostrar() + "\n" + jugadorActual.getNombre() + " escoge: " + str(indiceElegido))
  58.                 """
  59.                    Informa al usuario de los resultados indeseables que
  60.                    requieren una acción adicional.
  61.                """
  62.                 if movimiento == Movimiento.FUERADERANGO:
  63.                     Mensajes.messageInfo("Por favor escoge un indice que esté en el rango")
  64.                 elif movimiento == Movimiento.ESPACIOTOMADO:
  65.                     Mensajes.messageInfo("El espacio del cuadrado " + str(indiceElegido) + " esta tomado.")
  66.             # Actualiza el estado del juego cada turno
  67.             self.actualizarEstadoJuego()
  68.             marcarTurno += 1
  69.         """
  70.            Salió del bucle el juego, por lo que debe haber finalizado, por lo
  71.            que debemos informar a los jugadores del resultado
  72.        """
  73.         if self.__estado == Estado.EMPATE:
  74.             Mensajes.messageInfo("Empate!")
  75.         elif self.__estado == Estado.HAYGANADOR:
  76.             Mensajes.messageInfo(jugadorActual.getNombre() + " gana el TATETI")
  77.  
  78.     # Actualiza el estado global del juego
  79.     def actualizarEstadoJuego(self):
  80.         if self.__hayGanador() is True:
  81.             self.__estado = Estado.HAYGANADOR
  82.         elif self.__esGato() is True:
  83.             self.__estado = Estado.EMPATE
  84.  
  85.     """
  86.        Simplemente dice que el es un gato si el tablero está lleno
  87.        y nadie ganó todavía
  88.    """
  89.  
  90.     def __esGato(self):
  91.         cuadrados = self.__tablero.getCuadrado()
  92.         for i in range(1, len(cuadrados)):
  93.             if cuadrados[i] == '_':
  94.                 return False
  95.         return self.__tablero.configuracionGanadora() is False
  96.  
  97.     def __hayGanador(self):
  98.         return self.__tablero.configuracionGanadora() is True

Código Python:
Ver original
  1. from abc import ABCMeta
  2. import abc
  3.  
  4.  
  5. class Jugador(metaclass=ABCMeta):
  6.     def __init__(self, xnombre, xcaracter):
  7.         self._nombre = xnombre
  8.         self._caracter = xcaracter
  9.  
  10.     def getNombre(self):
  11.         return self._nombre
  12.  
  13.     def setNombre(self, nombre):
  14.         self._nombre = nombre
  15.  
  16.     def getCaracter(self):
  17.         return self._caracter
  18.  
  19.     def setCaracter(self, caracter):
  20.         self._caracter = caracter
  21.  
  22.     @abc.abstractmethod
  23.     def hacerMovimiento(self, tablero):
  24.         pass

Código Python:
Ver original
  1. from Jugador import Jugador
  2. from Mensajes import Mensajes
  3.  
  4.  
  5. class Humano(Jugador):
  6.     def __init__(self, xnombre, xcaracter):
  7.         Jugador.__init__(self, xnombre, xcaracter)
  8.  
  9.     def hacerMovimiento(self, tablero):
  10.         return Mensajes.requestInt(tablero.mostrar() + "\n" + self._nombre + ", por favor seleccione un cuadrado")

Código Python:
Ver original
  1. from Jugador import Jugador
  2. class Computadora(Jugador):
  3.     def __init__(self, xnombre, xcaracter):
  4.         Jugador.__init__(self, xnombre, xcaracter)
  5.  
  6.     """
  7.        Aquí es donde implementamos la IA de este sistema siguiendo el método simple
  8.        que fue escrito durante el laboratorio:
  9. *******     1. Gana si podemos
  10. *******     2. Bloquear si el humano puede ganar
  11. ******      3. Horquilla si es posible
  12. ********    4. Tome el centro si está abierto
  13. *******     5. Si hay una esquina abierta, tómala
  14. *****       6. Tome un cuadrado vacío 'lateral' si está disponible
  15. ************7. Toma cualquier plaza abierta
  16.    """
  17.  
  18.     def hacerMovimiento(self, tablero):
  19.         movimiento = 0
  20.         if tablero.encontrarEspacioGanador(caracter) != -1:
  21.             movimiento = tablero.encontrarEspacioGanador(caracter)
  22.             return movimiento
  23.         elif tablero.encontrarEspacioDeBloqueo(caracter) != -1:
  24.             movimiento = tablero.encontrarEspacioDeBloqueo(caracter)
  25.             return movimiento
  26.         elif tablero.encontrarBifurcacionEnEspacio(caracter) != -1:
  27.             movimiento = tablero.encontrarBifurcacionEnEspacio(caracter)
  28.             return movimiento
  29.         elif tablero.encontrarEspacioCentralAbierto() != -1:
  30.             movimiento = tablero.encontrarEspacioCentralAbierto()
  31.             return movimiento
  32.         elif tablero.encontrarEspacioDeEsquinaAbierto() != -1:
  33.             movimiento = tablero.encontrarEspacioDeEsquinaAbierto()
  34.             return movimiento
  35.         elif tablero.encontrarEspacioLateralVacio() != -1:
  36.             movimiento = tablero.encontrarEspacioLateralVacio()
  37.             return movimiento
  38.         else:
  39.             return self.__encontrarLugarVacio(tablero)
  40.  
  41.     # Contenedor para el comportamiento de movimiento predeterminado del super
  42.     def __encontrarLugarVacio(self, board):
  43.         lugares = board.getCuadrado()
  44.         for i in range(1, len(lugares)):
  45.             if lugares[i] == "_":
  46.                 return i
  47.         return -1

Código Python:
Ver original
  1. from Juego import Juego
  2. """
  3.    Código de: https://github.com/EvanOman/AI_TicTacToe
  4.  
  5.    9. Implementar el juego del TATETI
  6. """
  7. def main():
  8.     tateti = Juego()
  9.     tateti.play()
  10.  
  11. if __name__ == "__main__":
  12.     main()

El problema parece estar en las clases Tablero y Juego pero lo que cuesta creer es que en Java anda lo más bien y en python quede en bucle infinito.
Por favor, necesito de ayuda.

Espero sus respuestas.
__________________
Si te interesa, visita mi perfil de Linkedin. Gracias
  #3 (permalink)  
Antiguo 07/10/2019, 20:27
Avatar de detective_jd  
Fecha de Ingreso: abril-2011
Ubicación: Salto
Mensajes: 424
Antigüedad: 8 años, 6 meses
Puntos: 6
Respuesta: TATETI en Python

Resulta que en este código el verificarLineas provoca el bucle infinito siendo tantas iteraciones que Python no lo soporta, bueno tendré que cambiar de código para esto del polimorfismo.

Saludos
__________________
Si te interesa, visita mi perfil de Linkedin. Gracias



La zona horaria es GMT -6. Ahora son las 01:31.