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: 437
Antigüedad: 13 años
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: 437
Antigüedad: 13 años
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: 437
Antigüedad: 13 años
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
  #4 (permalink)  
Antiguo 28/02/2020, 15:53
Avatar de detective_jd  
Fecha de Ingreso: abril-2011
Ubicación: Salto
Mensajes: 437
Antigüedad: 13 años
Puntos: 6
Respuesta: TATETI en Python
Hola a todos, resulta que encontré un código de TATETI sencillo para jugar con la computadora:

Código Python: 
Ver original
  1. from Mensajes import Mensajes
  2. import random
  3.  
  4.  
  5. class TaTeTi:
  6.     def __init__(self):
  7.         self.__tamanio = 9
  8.         self.__figJugador = "X"
  9.         self.__figCompu = "O"
  10.         self.__tablero = ["1", "2", "3", "4", "5", "6", "7", "8", "9"]
  11.  
  12.     def play(self):
  13.         # Human starts first
  14.         turno = self.__figJugador
  15.         ganador = 0
  16.         # Set to 1, 2, or 3 when game is over
  17.         # Keep looping until someone wins or a tie
  18.         while ganador == 0:
  19.             if turno == self.__figJugador:
  20.                 self.__mueveJugador()
  21.                 turno = self.__figCompu
  22.             else:
  23.                 self.__mueveComputadora()
  24.                 turno = self.__figJugador
  25.             ganador = self.__verificarGanador()
  26.         Mensajes.messageInfo(self.__mostrarTablero() + "\n")
  27.         # Report the winner
  28.         if ganador == 1:
  29.             Mensajes.messageInfo("El juego ha terminado en empate.")
  30.         elif ganador == 2:
  31.             Mensajes.messageInfo("Jugador, has ganado! :)")
  32.         elif ganador == 3:
  33.             Mensajes.messageInfo("La computadora ha ganado! :(")
  34.         else:
  35.             Mensajes.messageInfo("¡Aquí hay un problema de lógica!")
  36.  
  37.     def __mostrarTablero(self):
  38.         res = "\n"
  39.         res += self.__tablero[0] + " | " + self.__tablero[1] + " | " + self.__tablero[2]
  40.         res += "\n-----------\n"
  41.         res += self.__tablero[3] + " | " + self.__tablero[4] + " | " + self.__tablero[5]
  42.         res += "\n-----------\n"
  43.         res += self.__tablero[6] + " | " + self.__tablero[7] + " | " + self.__tablero[8]
  44.         res += "\n"
  45.         return res
  46.  
  47.     """
  48.         Check for a winner.  Return
  49.         0 if no winner or tie yet
  50.         1 if it's a tie
  51.         2 if X won
  52.         3 if O won
  53.     """
  54.  
  55.     def __verificarGanador(self):
  56.         # Check horizontal wins
  57.         for i in range(0, 7, 3):
  58.             if self.__tablero[i] == self.__figJugador and self.__tablero[i + 1] == self.__figJugador and self.__tablero[i + 2] == self.__figJugador:
  59.                 return 2
  60.             if self.__tablero[i] == self.__figCompu and self.__tablero[i + 1] == self.__figCompu and self.__tablero[i + 2] == self.__figCompu:
  61.                 return 3
  62.         # Check vertical wins
  63.         for i in range(0, 3):
  64.             if self.__tablero[i] == self.__figJugador and self.__tablero[i + 3] == self.__figJugador and self.__tablero[i + 6] == self.__figJugador:
  65.                 return 2
  66.             if self.__tablero[i] == self.__figCompu and self.__tablero[i + 3] == self.__figCompu and self.__tablero[i + 6] == self.__figCompu:
  67.                 return 3
  68.         # Check for diagonal wins
  69.         if (self.__tablero[0] == self.__figJugador and self.__tablero[4] == self.__figJugador and self.__tablero[8] == self.__figJugador) or (
  70.             self.__tablero[2] == self.__figJugador and self.__tablero[4] == self.__figJugador and self.__tablero[6] == self.__figJugador
  71.         ):
  72.             return 2
  73.         if (self.__tablero[0] == self.__figCompu and self.__tablero[4] == self.__figCompu and self.__tablero[8] == self.__figCompu) or (
  74.             self.__tablero[2] == self.__figCompu and self.__tablero[4] == self.__figCompu and self.__tablero[6] == self.__figCompu
  75.         ):
  76.             return 3
  77.         # Check for tie
  78.         for i in range(0, self.__tamanio):
  79.             # If we find a number, then no one has won yet
  80.             if self.__tablero[i] != self.__figJugador and self.__tablero[i] != self.__figCompu:
  81.                 return 0
  82.         # If we make it through the previous loop, all places are taken, so it's a tie
  83.         return 1
  84.  
  85.     def __mueveJugador(self):
  86.         mueve = -1
  87.         while mueve == -1:
  88.             try:
  89.                 mueve = Mensajes.requestInt(self.__mostrarTablero() + "\n\n Ingrese su movimiento")
  90.                 while (
  91.                     mueve < 1
  92.                     or mueve > self.__tamanio
  93.                     or self.__tablero[mueve - 1] == self.__figJugador
  94.                     or self.__tablero[mueve - 1] == self.__figCompu
  95.                 ):
  96.                     if mueve < 1 or mueve > self.__tamanio:
  97.                         Mensajes.messageInfo("Por favor, ingrese un movimiento entre 1 y " + str(tamanio) + ".")
  98.                     else:
  99.                         Mensajes.messageInfo("Ese espacio esta ocupado. Por favor escoge otro espacio.")
  100.                     mueve = Mensajes.requestInt(self.__mostrarTablero() + "\n\n Ingrese su movimiento: ")
  101.             except Exception as ex:
  102.                 Mensajes.messageInfo(ex)
  103.         self.__tablero[mueve - 1] = self.__figJugador
  104.  
  105.     def __mueveComputadora(self):
  106.         mueve = -1
  107.         # First see if there's a move O can make to win
  108.         for i in range(0, self.__tamanio):
  109.             if self.__tablero[i] != self.__figJugador and self.__tablero[i] != self.__figCompu:
  110.                 curr = self.__tablero[i]
  111.                 self.__tablero[i] = self.__figCompu
  112.                 if self.__verificarGanador() == 3:
  113.                     Mensajes.messageInfo("La computadora esta moviendo a: " + str(i + 1))
  114.                     return
  115.                 else:
  116.                     self.__tablero[i] = curr
  117.         # See if there's a move O can make to block X from winning
  118.         for i in range(0, self.__tamanio):
  119.             if self.__tablero[i] != self.__figJugador and self.__tablero[i] != self.__figCompu:
  120.                 curr = self.__tablero[i]
  121.                 self.__tablero[i] == self.__figJugador
  122.                 if self.__verificarGanador() == 2:
  123.                     self.__tablero[i] = self.__figCompu
  124.                     Mensajes.messageInfo("La computadora esta moviendo a: " + str(i + 1))
  125.                     return
  126.                 else:
  127.                     self.__tablero[i] = curr
  128.         # Generate random move
  129.         while True:
  130.             mueve = random.randrange(self.__tamanio)
  131.             if self.__tablero[mueve] != self.__figJugador and self.__tablero[mueve] != self.__figCompu:
  132.                 break
  133.         Mensajes.messageInfo("La computadora se esta movimiento a: " + str(mueve + 1))
  134.         self.__tablero[mueve] = self.__figCompu

Pero no funciona bien, es decir siempre termino ganando en el juego, y no me doy cuenta de que cambiarle para que funcione bien el método mueveComputadora.

Espero sus respuestas y saludos.
__________________
Si te interesa, visita mi perfil de Linkedin. Gracias

Etiquetas: Ninguno
Atención: Estás leyendo un tema que no tiene actividad desde hace más de 6 MESES, te recomendamos abrir un Nuevo tema en lugar de responder al actual.
Respuesta


« Tema Anterior | Próximo Tema »


La zona horaria es GMT -6. Ahora son las 05:04.