# -*- coding: latin-1 -*-

#==========================================================================================================================================
import time
import random

from Code.Constantes import *
from Code.Traducir import tr

import VarGen

import Util

import Apertura
import AperturasTutor

import ControlPosicion
import Jugada
import MotorInternoGM
import MotoresExternos
import Tutor
import XMotorRespuesta
import Books

import DGT

import Gestor

import QT.QTUtil as QTUtil
import QT.QTUtil2 as QTUtil2
import QT.Iconos as Iconos
import QT.EntMaquina as EntMaquina
import QT.PantallaBooks as PantallaBooks

#==========================================================================================================================================
class Contador :

    def __init__( self, tiempoPendiente ) :

        self.tiempoPendiente = tiempoPendiente
        self.marcaTiempo = None
        self.txt = ""

    def texto( self, segs ) :
        if segs <= 0.0 :
            segs = 0.0
        tp = int(segs)
        txt = "%d:%02d"%( int(tp/60),tp%60 )
        return txt

    def ponSegExtra( self, segs ) :
        self.tiempoPendiente += segs

    def dameSegundos( self ) :
        if self.marcaTiempo :
            tp = self.tiempoPendiente - (time.clock()-self.marcaTiempo)
        else :
            tp = self.tiempoPendiente
        if tp <= 0.0 :
            tp = 0
        return int(tp)

    def etiqueta( self ) :
        return self.texto( self.dameSegundos() )

    def etiquetaDif( self ) :
        nvEti = self.etiqueta()
        if nvEti != self.txt :
            self.txt = nvEti
            return nvEti

        return None

    def etiquetaDGT( self ) :
        segs = self.dameSegundos()
        mins = segs/60
        segs = segs - mins*60
        hors = mins/60
        mins = mins - hors*60

        return "%d:%02d:%02d"%( hors, mins, segs )

    def siAgotado( self ) :
        if self.marcaTiempo :
            if (self.tiempoPendiente - ( time.clock()-self.marcaTiempo )) <= 0.0 :
                return True
        return False

    def iniciaMarcador( self ) :
        self.marcaTiempo = time.clock()

    def paraMarcador( self, tiempoJugada ) :
        if self.marcaTiempo :
            self.tiempoPendiente -= ( time.clock()-self.marcaTiempo )-tiempoJugada
            self.marcaTiempo = None

    def tiempoAplazamiento( self ) :
        self.paraMarcador( 0.00 )
        return self.tiempoPendiente

#==========================================================================================================================================
class GestorEntMaq( Gestor.Gestor ) :

    #--------------------------------------------------------------------------------------------------------------------------------
    def inicio( self, dic, aplazamiento=None ) :

        self.reinicio = dic

        self.tipoJuego = kJugEntMaq

        self.resultado = None
        self.siJuegaHumano = False
        self.estado = kJugando

        siBlancas = dic["SIBLANCAS"]
        self.siJugamosConBlancas = siBlancas
        self.siRivalConBlancas = not siBlancas

        self.siAtras = dic["ATRAS"]

        self.rmRival = None

        self.fen = dic["FEN"]
        if self.fen :
            self.siApertura = False
            cp = ControlPosicion.ControlPosicion()
            cp.leeFen( self.fen )
            self.partida.reset( cp )
            self.partida.pendienteApertura = False
        else :
            self.siApertura = True

        me = self.unMomento()
        self.siAperturaStd = False
        if self.siApertura :
            if dic["APERTURA"] :
                self.apertura = AperturasTutor.JuegaAperturaStd( dic["APERTURA"] )
                self.siAperturaStd = True
            else :
                self.apertura = Apertura.AperturaPol(100) # lee las aperturas

        self.book = dic.get( "BOOK", None )
        if self.book :
            self.book.polyglot()
            self.bookRR = dic.get( "BOOKRR", "mp" )

        self.siTutorActivado = VarGen.dgtDispatch == None
        self.pantalla.ponActivarTutor( True )

        self.ayudas = dic["AYUDAS"]
        self.ayudasPGN = self.ayudas # Se guarda para guardar el PGN

        self.nAjustarFuerza = dic.get( "AJUSTAR", kAjustarMejor )

        dr = dic["RIVAL"]
        motor = dr["MOTOR"]
        self.siRivalInterno = type(motor) == type(1)
        if self.siRivalInterno :
            self.xrival = MotorInternoGM.GestorMotor( motor, self )
            self.siApertura = dic["SIAPERTURA"]

        else :
            if motor.startswith( "*" ) :
                rival = MotoresExternos.buscaRival( self, motor )
            else :
                rival = self.configuracion.buscaRival( motor )
            r_t = dr["TIEMPO"]*100 # Se guarda en décimas -> milésimas
            r_p = dr["PROFUNDIDAD"]
            if r_t <= 0 :
                r_t = None
            if r_p <= 0 :
                r_p = None
            if r_t == None and r_p == None and not dic["SITIEMPO"]:
                r_t = 1000

            self.xrival = self.procesador.creaRival( rival, r_t, r_p, self.nAjustarFuerza!=kAjustarMejor )
            if self.nAjustarFuerza!=kAjustarMejor :
                self.xrival.maximizaMultiPV()

        dt = dic["TUTOR"]
        motor = dt["MOTOR"]
        if motor.startswith( "*" ) :
            tutor = MotoresExternos.buscaRival( self, motor )
        else :
            tutor = self.configuracion.buscaRival( motor )
        t_t = dt["TIEMPO"]*100 # Se guarda en décimas -> milésimas
        if t_t <= 0 :
            t_t = None

        self.xtutor = self.procesador.creaTutor( tutor, t_t, None )

        self.xrival.siBlancas = self.siRivalConBlancas

        self.siPrimeraJugadaHecha = False

        self.siTiempo = dic["SITIEMPO"]
        if self.siTiempo :
            self.maxSegundos = dic["MINUTOS"]*60.0
            self.segundosJugada = dic["SEGUNDOS"]
            self.segExtra= dic.get("MINEXTRA",0)*60.0

            self.tiempo = {}
            self.tiempo[True] = Contador( self.maxSegundos )
            self.tiempo[False] = Contador( self.maxSegundos )
            if self.segExtra :
                self.tiempo[self.siJugamosConBlancas].ponSegExtra(self.segExtra)

        me.final()

        #-Aplazamiento 1/2--------------------------------------------------
        if aplazamiento :
            self.partida.recuperaDeTexto( aplazamiento["JUGADAS"] )
            self.siApertura = False # Si no no arranca correctamente, no tiene sentido que se aplace en la apertura
            self.partida.pendienteApertura = aplazamiento["PENDIENTEAPERTURA"]
            self.partida.apertura = None if aplazamiento["APERTURA"] is None else self.listaAperturasStd.dic[aplazamiento["APERTURA"]]

            self.siTutorActivado = aplazamiento["SITUTOR"]
            self.pantalla.ponActivarTutor( self.siTutorActivado )
            self.ayudas = aplazamiento["AYUDAS"]

            self.siTiempo = aplazamiento["SITIEMPO"]
            if self.siTiempo :
                self.maxSegundos = aplazamiento["MAXSEGUNDOS"]
                self.segundosJugada = aplazamiento["SEGUNDOSJUGADA"]
                self.segExtra= aplazamiento.get("SEGEXTRA",0)

                self.tiempo = {}
                self.tiempo[True] = Contador( aplazamiento["TIEMPOBLANCAS"] )
                self.tiempo[False] = Contador( aplazamiento["TIEMPONEGRAS"] )
                if self.segExtra :
                    self.tiempo[self.siJugamosConBlancas].ponSegExtra(self.segExtra)

                self.siPrimeraJugadaHecha = False

        #-------------------------------------------------------------------

        if self.siAtras :
            self.pantalla.ponToolBar( ( k_finpartida, k_rendirse,k_atras,k_reiniciar,k_aplazar,k_otros ) )
        else :
            self.pantalla.ponToolBar( ( k_finpartida, k_rendirse,k_reiniciar,k_aplazar,k_otros ) )

        self.pantalla.activaJuego( True, self.siTiempo )

        self.ponMensajero( self.mueveHumano )
        self.ponPosicion( self.partida.ultPosicion )
        self.mostrarIndicador( True )
        if self.ayudasPGN :
            self.ponAyudasEM( )
        else :
            self.quitaAyudas( siQuitarAtras = not self.siAtras)
        self.ponPiezasAbajo( siBlancas )
        self.ponRotulo1( tr( "RIVAL" ) + ": <b>" + self.xrival.nombre )
        if self.ayudasPGN :
            self.ponRotulo2( tr( "TUTOR" ) + ": <b>" + self.xtutor.nombre )
        else :
            self.ponRotulo2( "" )

        self.ponCapturasPorDefecto()

        self.pgnRefresh( True )

        #-Aplazamiento 2/2--------------------------------------------------
        if aplazamiento :
            self.mueveJugada( "f" )
        #-------------------------------------------------------------------

        if self.siTiempo :
            self.siPrimeraJugadaHecha = False
            tpBL = self.tiempo[True].etiqueta()
            tpNG = self.tiempo[False].etiqueta()
            rival = self.xrival.nombre
            jugador = self.configuracion.jugador
            bl, ng = jugador, rival
            if self.siRivalConBlancas :
                bl, ng = ng, bl
            self.pantalla.ponDatosReloj( bl, tpBL, ng, tpNG )
            self.refresh()

        self.siAnalizadoTutor = False

        self.ponPosicionDGT()

        self.siguienteJugada()

    #--------------------------------------------------------------------------------------------------------------------------------
    def analizaTutorAY( self ):
        if self.ayudasPGN > 0 :
            self.analizaTutor()

    #--------------------------------------------------------------------------------------------------------------------------------
    def ponReloj(self):

        if (not self.siTiempo) or \
            (not self.siPrimeraJugadaHecha) or \
            self.estado != kJugando :
            return

        def mira( siBlancas ) :
            ot = self.tiempo[siBlancas]

            eti = ot.etiquetaDif()
            if eti :
                if siBlancas :
                    self.pantalla.ponRelojBlancas( eti )
                else :
                    self.pantalla.ponRelojNegras( eti )

            if ot.siAgotado() :
                siJugador = self.siJugamosConBlancas == siBlancas
                if siJugador and QTUtil2.pregunta( self.pantalla, tr( "HA_GANADO_TIEMPO", self.xrival.nombre ) + "\n\n" + tr("TIEMPO_MINUTOS_EXTRA_JUEGO") ) :
                    minX = EntMaquina.dameMinutosExtra( self.pantalla )
                    if minX :
                        ot.ponSegExtra(minX*60)
                        return True
                self.ponResultado( kGanaRivalTiempo if siJugador else kGanamosTiempo )
                return False

            return True

        if VarGen.dgt :
            DGT.writeClocks( self.tiempo[True].etiquetaDGT(), self.tiempo[False].etiquetaDGT() )

        if mira( True ) :
            mira( False )
        self.refresh()

    #--------------------------------------------------------------------------------------------------------------------------------
    def relojStart( self, siUsuario ) :
        if self.siTiempo and self.siPrimeraJugadaHecha :
            self.tiempo[ siUsuario == self.siJugamosConBlancas ].iniciaMarcador()
            self.pantalla.iniciaReloj(self.ponReloj, transicion = 200 )

    #--------------------------------------------------------------------------------------------------------------------------------
    def relojStop( self, siUsuario ) :
        if self.siTiempo and self.siPrimeraJugadaHecha :
            self.tiempo[ siUsuario == self.siJugamosConBlancas ].paraMarcador(self.segundosJugada)
            self.ponReloj()
            self.pantalla.paraReloj( )

    #--------------------------------------------------------------------------------------------------------------------------------
    def procesarAccion( self, clave ) :

        if clave == k_finpartida :
            self.finalizar()

        elif clave == k_rendirse :
            self.rendirse()

        elif clave == k_atras :
            self.atras()

        elif clave == k_reiniciar :
            self.reiniciar(True)

        elif clave == k_otros :
            liMasOpciones = []
            if self.siJuegaHumano or self.siTerminada() :
                liMasOpciones.append(( "libros", tr( "LIBRO_CONSULTA" ), Iconos.TB_Libros() ) )
            if self.estado == kJugando and not self.siRivalInterno :
                liMasOpciones.append( (None,None,None) )
                liMasOpciones.append( ( "rival", tr( "CAMBIO_RIVAL" ), Iconos.Motor() ) )

            resp = self.otros(liMasOpciones, siCambioTutor = self.ayudasPGN > 0, siSonidos = True)
            if resp == "libros" :
                resp1 = self.libros( "M" ) # gestor
                if resp1 :
                    self.mueveHumano( resp1[:2], resp1[2:4], resp1[4:])
            elif resp == "rival" :
                self.cambioRival()

        elif clave == k_aplazar :
            self.aplazar()

        elif clave in self.procesador.liOpcionesInicio :
            self.procesador.procesarAccion( clave )

        else :
            Gestor.Gestor.rutinaAccionDef( self, clave )

    #--------------------------------------------------------------------------------------------------------------------------------
    def reiniciar( self, siPregunta ) :
        if siPregunta :
            if not QTUtil2.pregunta( self.pantalla, tr( "PREGUNTA_REINICIAMOS" ) ) :
                return

        self.partida.reset()
        if self.siTiempo :
            self.pantalla.paraReloj()
        self.inicio( self.reinicio )

    #--------------------------------------------------------------------------------------------------------------------------------
    def aplazar( self ) :
        if QTUtil2.pregunta( self.pantalla, tr( "PREGUNTA_APLAZAMOS" ) ) :

            aplazamiento = {}
            aplazamiento["EMDIC"] = self.reinicio

            aplazamiento["TIPOJUEGO"] = self.tipoJuego
            aplazamiento["SIBLANCAS"] = self.siJugamosConBlancas
            aplazamiento["JUGADAS"] = self.partida.guardaEnTexto()
            aplazamiento["SITUTOR"] = self.siTutorActivado
            aplazamiento["AYUDAS"] = self.ayudas

            aplazamiento["SIAPERTURA"] = self.siApertura
            aplazamiento["PENDIENTEAPERTURA"] = self.partida.pendienteApertura
            aplazamiento["APERTURA"] = self.partida.apertura.a1h8 if self.partida.apertura else None

            aplazamiento["SITIEMPO"] = self.siTiempo
            if self.siTiempo :
                aplazamiento["MAXSEGUNDOS"] = self.maxSegundos
                aplazamiento["SEGUNDOSJUGADA"] = self.segundosJugada
                aplazamiento["TIEMPOBLANCAS"] = self.tiempo[True].tiempoAplazamiento()
                aplazamiento["TIEMPONEGRAS"] = self.tiempo[False].tiempoAplazamiento()

            self.configuracion.graba( aplazamiento )
            self.pantalla.accept()

    #--------------------------------------------------------------------------------------------------------------------------------
    def finalX( self ) :
        return self.finalizar()

    #--------------------------------------------------------------------------------------------------------------------------------
    def finalizar( self ) :
        if self.estado == kFinJuego :
            return True
        siJugadas = self.partida.numJugadas() > 0
        if self.siTiempo :
            self.pantalla.paraReloj()
        if siJugadas :
            if not QTUtil2.pregunta( self.pantalla, tr( "FINALIZAS" ) ) :
                return False # no abandona
            self.resultado = kDesconocido
            self.partida.liJugadas[-1].siDesconocido = True
            self.guardarNoTerminados( )
            self.ponFinJuego()
        else :
            self.pantalla.activaJuego( False, False )
            self.quitaCapturas()
            self.procesador.inicio()

        return False

    #--------------------------------------------------------------------------------------------------------------------------------
    def rendirse( self ) :
        if self.estado == kFinJuego :
            return True
        siJugadas = self.partida.numJugadas() > 0
        if self.siTiempo :
            self.pantalla.paraReloj()
        if siJugadas :
            if not QTUtil2.pregunta( self.pantalla, tr( "TE_RINDES" ) ) :
                return False # no abandona
            self.resultado = kGanaRival
            self.partida.liJugadas[-1].siAbandono = True
            self.guardarGanados( False )
            self.ponFinJuego()
        else :
            self.pantalla.activaJuego( False, False )
            self.quitaCapturas()
            self.procesador.inicio()

        return False

    #--------------------------------------------------------------------------------------------------------------------------------
    def atras( self ) :
        if self.partida.numJugadas() :
            if QTUtil2.pregunta( self.pantalla, tr( "IR_ATRAS" ) ) :
                if self.ayudas :
                    self.ayudas -= 1
                self.ponAyudasEM(  )
                self.partida.anulaUltimoMovimiento( self.siJugamosConBlancas )
                self.siApertura = False
                if not self.fen :
                    self.listaAperturasStd.asignaApertura( self.partida )
                self.ponteAlFinal()
                self.siAnalizadoTutor = False
                self.siguienteJugada()

    #--------------------------------------------------------------------------------------------------------------------------------
    def siguienteJugada( self ) :

        if self.estado == kFinJuego :
            return

        self.estado = kJugando

        self.siJuegaHumano = False
        self.ponVista()

        siBlancas = self.partida.siBlancas()

        if self.partida.numJugadas() > 0 :
            jgUltima = self.partida.liJugadas[-1]
            if jgUltima :
                if jgUltima.siJaqueMate :
                    self.ponResultado( kGanaRival if self.siJugamosConBlancas == siBlancas else kGanamos )
                    return
                if jgUltima.siAhogado :
                    self.ponResultado( kTablas )
                    return
                if jgUltima.siTablasRepeticion :
                    self.ponResultado( kTablasRepeticion )
                    return
                if jgUltima.siTablas50 :
                    self.ponResultado( kTablas50 )
                    return
                if jgUltima.siTablasFaltaMaterial :
                    self.ponResultado( kTablasFaltaMaterial )
                    return

        self.ponIndicador( siBlancas )
        self.refresh()

        siRival = siBlancas == self.siRivalConBlancas

        if siRival :
            self.pensando(True)
            self.desactivaTodas( )

            self.relojStart(False)

            siEncontrada = False
            if self.siApertura :
                if self.siAperturaStd :
                    siEncontrada, desde, hasta, coronacion = self.apertura.juegaMotor( )
                else :
                    if self.book : # Sin apertura estandar, con apertura y libro
                        siEncontrada, desde, hasta, coronacion = self.eligeJugadaBook( )
                        if siEncontrada :
                            self.siApertura = False # para que no haya problemas de busqueda futura, ya seguimos siempre el libro
                    if not siEncontrada : # Nada en el libro en su caso buscamos la apertura normal
                        if self.nAjustarFuerza :
                            siEncontrada, desde, hasta, coronacion = self.eligeJugadaBookAjustada( )
                        if not siEncontrada :
                            siEncontrada, desde, hasta, coronacion = self.apertura.juegaMotor( self.partida.fenActual() )

            if not siEncontrada and self.book : # Sin apertura y con libro
                siEncontrada, desde, hasta, coronacion = self.eligeJugadaBook( )

            if siEncontrada :
                self.rmRival = XMotorRespuesta.RespuestaMotor("Apertura")
                self.rmRival.desde = desde
                self.rmRival.hasta = hasta
                self.rmRival.coronacion = coronacion

            else :

                if self.siTiempo :
                    tiempoBlancas = self.tiempo[True].tiempoPendiente
                    tiempoNegras = self.tiempo[False].tiempoPendiente
                    self.rmRival = self.xrival.juegaTiempo(tiempoBlancas, tiempoNegras, self.segundosJugada, nAjustado=self.nAjustarFuerza )

                else :
                    if self.siRivalInterno :
                        self.rmRival = self.xrival.juega()
                    else :
                        self.rmRival = self.xrival.juega(nAjustado=self.nAjustarFuerza)

            self.relojStop(False)

            self.pensando(False)
            resp = self.mueveRival( self.rmRival )

            if resp :
                self.siguienteJugada()

        else :

            self.siJuegaHumano = True
            self.relojStart(True)
            self.activaColor( siBlancas )

    #--------------------------------------------------------------------------------------------------------------------------------
    def eligeJugadaBookBase( self, book, bookRR ) :
        fen = self.partida.fenActual()
        listaJugadas = book.miraListaJugadas( fen )
        if listaJugadas :
            if bookRR == "su" :
                resp = PantallaBooks.eligeJugadaBooks( listaJugadas, self.partida.ultPosicion.siBlancas )
            elif bookRR == "mp" :
                resp = listaJugadas[0][0], listaJugadas[0][1], listaJugadas[0][2]
                nmax = listaJugadas[0][4]
                for desde,hasta,coronacion,pgn,peso in listaJugadas :
                    if peso > nmax :
                        resp = desde,hasta,coronacion
                        nmax = peso
            elif bookRR == "au" :
                pos = random.randint(0,len(listaJugadas)-1)
                resp = listaJugadas[pos][0], listaJugadas[pos][1], listaJugadas[pos][2]
            else :
                li = [ int(x[4]*1000000) for x in listaJugadas ]
                t = sum(li)
                num = random.randint(1,t)
                pos = 0
                t = 0
                for n, x in enumerate(li) :
                    t += x
                    if num <= t :
                        pos = n
                        break
                resp = listaJugadas[pos][0], listaJugadas[pos][1], listaJugadas[pos][2]
            return True, resp[0], resp[1], resp[2]
        else :
            return False, None, None, None

        return resp
    #--------------------------------------------------------------------------------------------------------------------------------
    def eligeJugadaBook( self ) :
        return self.eligeJugadaBookBase( self.book, self.bookRR )
    #--------------------------------------------------------------------------------------------------------------------------------
    def eligeJugadaBookAjustada( self ) :
        if self.nAjustarFuerza < 1000 :
            return False, None, None, None
        dicPersonalidad = self.configuracion.liPersonalidades[self.nAjustarFuerza-1000]
        nombook = dicPersonalidad.get( "BOOK", None )
        if (nombook is None) or (not Util.existeFichero(nombook)):
            return False, None, None, None

        book = Books.Libro( "P", nombook, nombook, True )
        book.polyglot()
        return self.eligeJugadaBookBase( book, "pr" )

    #--------------------------------------------------------------------------------------------------------------------------------
    def mueveHumano( self, desde, hasta, coronacion = None ) :

        if self.siJuegaHumano :
            self.paraHumano()
        else :
            self.sigueHumano()
            return False

        movimiento = desde + hasta

        # Peón coronando
        if not coronacion and self.partida.ultPosicion.siPeonCoronando( desde, hasta ) :
            coronacion = self.tablero.peonCoronando(self.partida.ultPosicion.siBlancas)
            if coronacion is None :
                self.sigueHumano()
                return False
        if coronacion :
            movimiento += coronacion

        siBien, mens, jg = Jugada.dameJugada( self.partida.ultPosicion, desde, hasta, coronacion )

        if self.siTeclaPanico :
            self.sigueHumano()
            return False

        if siBien :

            siMirarTutor = self.siTutorActivado

            if self.siApertura :
                if self.siAperturaStd :
                    if self.apertura.compruebaHumano( desde, hasta ) :
                        siMirarTutor = False
                    else :
                        if self.apertura.activa :
                            respuesta, desde, hasta, coronacion = self.apertura.intentaJugarHumano( self, jg, desde, hasta )
                            if respuesta == kSigueApertura :
                                self.tablero.ponPosicion( self.partida.ultPosicion )
                                if self.ayudas :
                                    self.ayudas -= 1
                            elif respuesta == kSigueUsuario :
                                self.siApertura = False
                            else : # kMalApertura
                                self.sigueHumano()
                                return False
                            siBien, mens, jgT = Jugada.dameJugada( self.partida.ultPosicion, desde, hasta, coronacion )
                            siMirarTutor = False
                            jg = jgT
                elif siMirarTutor and self.apertura.compruebaHumano( self.partida.fenActual(), desde, hasta ) :
                    siMirarTutor = False

            if self.siTeclaPanico :
                self.sigueHumano()
                return False

            if siMirarTutor :
                if not self.siAnalizadoTutor :
                    self.analizaTutorAY()
                if self.mrmTutor.mejorMovQue(movimiento) :
                    if not jg.siJaqueMate :
                        tutor = Tutor.Tutor( self, self, jg, desde, hasta, False )

                        if self.siApertura :
                            liApPosibles = self.listaAperturasStd.listaAperturasPosibles( self.partida )
                        else :
                            liApPosibles = None

                        if tutor.elegir( self.ayudas > 0, self.configuracion.cTableroT, liApPosibles = liApPosibles ) :
                            if self.ayudas > 0 : # doble entrada a tutor.
                                self.reponPieza( desde )
                                self.ayudas -= 1
                                desde = tutor.desde
                                hasta = tutor.hasta
                                coronacion = tutor.coronacion
                                siBien, mens, jgTutor = Jugada.dameJugada( self.partida.ultPosicion, desde, hasta, coronacion )
                                if siBien :
                                    jg = jgTutor
                        elif self.configuracion.guardarVariantesTutor :
                            tutor.ponVariantes( jg, 1+self.partida.numJugadas()/2 )

                        del tutor

            if self.siTeclaPanico :
                self.sigueHumano()
                return False

            self.relojStop(True)

            if self.siApertura and self.siAperturaStd :
                self.siApertura = self.apertura.haJugadoHumano( desde, hasta )

            self.movimientosPiezas( jg.liMovs )

            self.partida.ultPosicion = jg.posicion
            self.masJugada( jg )
            self.error = ""
            self.siguienteJugada()
            return True
        else :
            self.error = mens
            self.sigueHumano()
            return False

    #--------------------------------------------------------------------------------------------------------------------------------
    def masJugada( self, jg ) :

        if not self.siPrimeraJugadaHecha :
            self.siPrimeraJugadaHecha = True

        # Preguntamos al mono si hay movimiento
        if self.siTerminada() :
            jg.siJaqueMate = jg.siJaque
            jg.siAhogado = not jg.siJaque

        self.partida.liJugadas.append( jg )
        if self.partida.pendienteApertura :
            self.listaAperturasStd.asignaApertura( self.partida )

        resp = self.partida.si3repetidas()
        if resp :
            jg.siTablasRepeticion = True
            rotulo = ""
            for j in resp :
                rotulo += "%d,"%(j/2+1,)
            rotulo = rotulo.strip(",")
            self.rotuloTablasRepeticion = rotulo

        if self.partida.ultPosicion.movPeonCap >= 50 :
            jg.siTablas50 = True

        if self.partida.ultPosicion.siFaltaMaterial() :
            jg.siTablasFaltaMaterial = True

        self.ponFlechaSC( jg.desde, jg.hasta )
        self.ponAyudasEM(  )

        self.pgnRefresh(self.partida.ultPosicion.siBlancas)

        self.ponPosicionDGT()

        self.refresh()

    #--------------------------------------------------------------------------------------------------------------------------------
    def mueveRival( self, respMotor ) :

        desde = respMotor.desde
        hasta = respMotor.hasta

        coronacion = respMotor.coronacion

        siBien, mens, jg = Jugada.dameJugada( self.partida.ultPosicion, desde, hasta, coronacion )
        if siBien :
            self.partida.ultPosicion = jg.posicion
            if self.siApertura or not self.siTutorActivado :
                self.siAnalizadoTutor = False
            else :
                self.siAnalizadoTutor = self.ayudasPGN > 0
                if self.siAnalizadoTutor :
                    self.analizaTutor() # Que analice antes de activar humano, para que no tenga que esperar
            self.masJugada( jg )
            self.beepExtendido()
            self.movimientosPiezas( jg.liMovs, True )
            self.error = ""

            return True
        else :
            self.error = mens
            return False

    #--------------------------------------------------------------------------------------------------------------------------------
    def ponResultado( self, quien ) :
        self.resultado = quien
        self.desactivaTodas( )
        self.siJuegaHumano = False

        self.beepResultado( quien )

        nombreContrario = self.xrival.nombre

        mensaje = tr("PARTIDA_TERMINADA")
        if quien == kGanamos :
            mensaje = tr( "ENHORABUENA", nombreContrario )

        elif quien == kGanaRival :
            mensaje = tr( "HA_GANADO", nombreContrario )

        elif quien == kTablas :
            mensaje = tr( "TABLAS_CONTRA", nombreContrario )

        elif quien == kTablasRepeticion :
            mensaje = tr( "TABLAS_3REPETICION", self.rotuloTablasRepeticion, nombreContrario )
            self.resultado = kTablas

        elif quien == kTablas50 :
            mensaje = tr( "TABLAS_50", nombreContrario )
            self.resultado = kTablas

        elif quien == kTablasFaltaMaterial :
            mensaje = tr( "TABLAS_FALTA_MATERIAL", nombreContrario )
            self.resultado = kTablas

        elif quien == kGanamosTiempo :
            mensaje = tr( "ENHORABUENA_TIEMPO", nombreContrario )
            self.resultado = kGanamos

        elif quien == kGanaRivalTiempo :
            mensaje = tr( "HA_GANADO_TIEMPO", nombreContrario )
            self.resultado = kGanaRival

        self.guardarGanados(quien==kGanamos)
        if quien != kGanaRivalTiempo : # Ya que el mensaje ya se ha usado, para añadir minutos
            QTUtil2.mensaje( self.pantalla, mensaje )
        if QTUtil2.pregunta( self.pantalla, tr("PREGUNTA_VOLVEMOS_A_JUGAR")) :
            self.reiniciar(False)
        else :
            self.ponFinJuego( )

    #--------------------------------------------------------------------------------------------------------------------------------
    def ponFinJuego( self ) :
        self.pensando(False)
        if self.siTiempo :
            self.pantalla.paraReloj()
        Gestor.Gestor.ponFinJuego( self )

    #--------------------------------------------------------------------------------------------------------------------------------
    def ponAyudasEM( self ) :
        self.ponAyudas( self.ayudas, siQuitarAtras = not self.siAtras )

    #--------------------------------------------------------------------------------------------------------------------------------
    def cambioRival( self ) :

        dic = EntMaquina.cambioRival( self.pantalla, self.configuracion, self.reinicio )

        if dic :
            self.reinicio = dic

            siBlancas = dic["SIBLANCAS"]

            self.siAtras = dic["ATRAS"]
            if self.siAtras :
                self.pantalla.ponToolBar( ( k_finpartida, k_rendirse,k_atras,k_reiniciar,k_aplazar,k_otros ) )
            else :
                self.pantalla.ponToolBar( ( k_finpartida, k_rendirse,k_reiniciar,k_aplazar,k_otros ) )

            self.rmRival = None

            self.nAjustarFuerza = dic[ "AJUSTAR" ]

            dr = dic["RIVAL"]
            motor = dr["MOTOR"]
            if motor.startswith( "*" ) :
                rival = MotoresExternos.buscaRival( self, motor )
            else :
                rival = self.configuracion.buscaRival( motor )
            r_t = dr["TIEMPO"]*100 # Se guarda en décimas -> milésimas
            r_p = dr["PROFUNDIDAD"]
            if r_t <= 0 :
                r_t = None
            if r_p <= 0 :
                r_p = None
            if r_t == None and r_p == None and not dic["SITIEMPO"]:
                r_t = 1000

            self.xrival = self.procesador.creaRival( rival, r_t, r_p, self.nAjustarFuerza!=kAjustarMejor )

            self.xrival.siBlancas = not siBlancas

            # self.ponPiezasAbajo( siBlancas )
            self.ponRotulo1( tr( "RIVAL" ) + ": <b>" + self.xrival.nombre )

            if siBlancas != self.siJugamosConBlancas :
                self.siJugamosConBlancas = siBlancas
                self.siRivalConBlancas = not siBlancas

                self.siguienteJugada()

