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

DEBUG=False

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

from Constantes import *
from Traducir import tr

import VarGen

if DEBUG :
    prlk( "DEBUG-Remoto "*10 )

import Util

import ControlPosicion
import Jugada
import Tutor
import Remoto
import Analisis

import Gestor

import QT.QTUtil2 as QTUtil2
import QT.DatosRemoto as DatosRemoto

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

    #--------------------------------------------------------------------------------------------------------------------------------
    def conexion( self, siServidor ) :
        self.siDesconectado = True
        self.siServidor = siServidor
        self.socket = None

        if DEBUG :
            if siServidor :
                self.pantalla.move(0,0)
            else :
                self.pantalla.move(0,400)

        if siServidor :
            resp = self.lanzaServidor()
        else :
            resp = self.lanzaCliente()
        if resp :
            self.inicio()
        else :
            self.terminar()

    #-----------------------------------------------------------------------------------
    def lanzaServidor( self ) :
        dic = DatosRemoto.confServidor( self )
        if dic :

            self.server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            self.server.bind((dic["IP"], dic["PUERTO"]))
            self.server.listen(1)
            self.server.settimeout(0.1)

            dic["SERVER"] = self.server

            self.dicRemoto = dic

            resp = DatosRemoto.esperaAlCliente( self.pantalla, dic, self.configuracion )
            if resp :
                self.dicDatos, self.socket = resp

                return True
            self.server.close()
            self.server = None
        return False

    #-----------------------------------------------------------------------------------
    def lanzaCliente( self ) :
        resp = DatosRemoto.conectaAlServidor( self.pantalla, self.configuracion )
        if resp :
            self.dicDatos, self.socket = resp
            return True
        return False

    #-----------------------------------------------------------------------------------
    def inicio( self ) :

        self.siDesconectado = False
        self.siGestionaRutina = False # Para las propuestas

        self.estado = kInicio

        self.socket.setblocking(1)
        self.socket.settimeout(0.1)

        liOpciones = [ k_terminar ]
        if self.siServidor :
            liOpciones.append( k_nuevapartida )
        self.pantalla.ponToolBar( liOpciones )
        self.pantalla.chat.show()

        self.chat = self.pantalla.chat
        self.correos = self.chat.correos

        self.base = self.pantalla.base
        self.ponRelojBlancas = self.base.ponRelojBlancas
        self.ponRelojRegras = self.base.ponRelojNegras

        self.jugador = self.configuracion.jugador
        self.rival = self.dicDatos["RIVAL"] #+ ("CLIENTE" if self.siServidor else "SERVER")
        self.clave = self.dicDatos["CLAVE"]
        self.chat.configuracion( self.jugador, self.rival, self.clave, self.enlaceEnvio )
        self.siDesconectado = False
        self.ponCapturasPorDefecto()

        self.color = None

        self.correos( "S", tr( "CONECTADO" ) )
        self.correos( "S", tr( "RIVAL" ) + " : " + self.rival )

        self.pantalla.iniciaReloj(self.enlaceTimer)

    #-----------------------------------------------------------------------------------
    def enlaceTimer( self ) :
        if self.siGestionaRutina : # Para que no se dupliquen los procesos, cuando es una rutina quien espera la respuesta del otro usuario
            return

        if self.siDesconectado :
            return
        self.recibe()

        if self.estado == kJugando :
            self.ponRelojJugador()

    #-----------------------------------------------------------------------------------
    def enlaceEnvio( self, mensaje ) :
        if self.siDesconectado :
            return

        try :
            self.socket.send( mensaje.texto() )
        except socket.error, msg :
            self.desconectado( str(msg) )

    #--------------------------------------------------------------------------------------------------------------------------------
    def recibe(self):

        try :
            txt = self.socket.recv(1024)
            if not txt :
                self.desconectado( "" )
                return
        except socket.timeout :
            return None
        except socket.error, msg :
            self.desconectado( str(msg) )
            return None
        mens = Remoto.Mensaje()
        mens.lee(txt)
        for uno in mens :
            tipo = uno.tipo
            if tipo == Remoto.MENS_NADA :
                pass
            elif tipo == Remoto.MENS_RELOJ :
                tm = uno.texto
                self.ponReloj( not self.siJugamosConBlancas, tm )

            elif tipo == Remoto.MENS_JUGADA :
                tm = uno.texto
                li = tm.split( "-" )
                desde = li[0]
                hasta = li[1]
                coronacion = li[2]
                self.mueveRival( desde, hasta, coronacion )

            elif tipo == Remoto.MENS_CHAT :
                self.correos( "R", uno.texto )

            elif tipo == Remoto.MENS_TABLAS :
                self.respuestaSolicitudTablas()

            elif tipo == Remoto.MENS_ATRAS :
                self.respuestaSolicitudAtras()

            elif tipo == Remoto.MENS_REINICIAR :
                self.respuestaSolicitudReiniciar()

            elif tipo == Remoto.MENS_RESPUESTA :
                self.respuesta = uno.texto

            elif tipo == Remoto.MENS_RENDIRSE :
                self.ponResultado( kGanamos )

            elif tipo == Remoto.MENS_PIERDETIEMPO :
                self.ponResultado( kGanamosTiempo )

            elif tipo == Remoto.MENS_NUEVA :
                dic = Util.txt2dic( uno.texto )
                dic["RIVAL"] = self.rival
                dic["COLOR"] = "B" if dic["COLOR"] == "W" else "W"
                self.nuevaPartida(dic)

        return None

    #--------------------------------------------------------------------------------------------------------------------------------
    def desconectado( self, msg ) :
        """
        Desconexión sin aviso
        """
        siTerminar = False
        self.siDesconectado = True
        if self.siServidor :
            resp = DatosRemoto.esperaAlCliente( self.pantalla, self.dicRemoto, self.configuracion )
            if resp :
                self.dicDatos, self.socket = resp
            else :
                siTerminar = True
        else :
            siTerminar = not self.lanzaCliente()

        if siTerminar :
            self.terminar()
        else :
            self.siDesconectado = False

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

        if clave == k_terminar :
            self.terminar()

        elif clave == k_nuevapartida :
            self.confNuevaPartida()

        elif clave == k_reiniciar :
            self.proponeReiniciar()

        elif clave == k_tablas :
            self.proponeTablas()

        elif clave == k_atras :
            self.proponeAtras()

        elif clave == k_otros :
            self.otros(siSonidos = True)

        elif clave == k_rendirse :
            self.rendirse()

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

    #--------------------------------------------------------------------------------------------------------------------------------
    def confNuevaPartida( self ) :
        # Pedimos los datos
        dic = DatosRemoto.nuevaPartida( self.pantalla, self.configuracion, self.color )
        if dic is None :
            return

        color = dic["COLOR"]
        if color == "R" :
            color = "W" if random.randint( 0, 1 ) else "B"
        dic["COLOR"] = color

        # Enviamos los datos al rival
        mens = Remoto.Mensaje()
        mens.nuevo( Remoto.MENS_NUEVA, Util.dic2txt( dic ) )
        self.socket.send( mens.texto() )

        # Iniciamos la partida
        self.partida.reset()
        self.nuevaPartida( dic )

    #-----------------------------------------------------------------------------------
    def nuevaPartida( self, dic ) :

        self.reinicio = dic

        self.tipoJuego = kJugRemoto

        self.resultado = None
        self.siJuegaLocal = False
        self.ultimoTMenviado = None
        self.controlTiempo = False

        color = dic["COLOR"]
        siBlancas = color == "W"
        self.siJugamosConBlancas = siBlancas
        self.siRivalConBlancas = not siBlancas

        self.fen = dic["FEN"]
        cp = ControlPosicion.ControlPosicion()
        if self.fen :
            cp.leeFen( self.fen )
        else :
            cp.posInicial()
        self.partida.reset( cp )

        self.siTutorActivado = VarGen.dgtDispatch == None

        self.pantalla.ponActivarTutor( True )

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

        if self.ayudas :
            me = self.unMomento()
            self.analizaTutor()
            me.final()

        self.tiempoTotal = dic["MINUTOS"]*60.0
        self.tiempoJugada = dic["SEGUNDOS"]*1.0
        self.tiempoUtilizado = 0.0
        self.marcaTiempo = None
        self.controlTiempo = False

        self.teclaPanico = 32
        self.siTeclaPanico = False

        # Lo ponemos en el chat
        self.correos( "S", tr( "JUGAMOS_CON" ) + " " + tr("PGN_WHITE" if siBlancas else "PGN_BLACK") )
        self.correos( "S", "%s : %d"%(tr( "TIEMPO_MINUTOS_TOTAL" ), dic["MINUTOS"] ) )
        if self.tiempoJugada :
            self.correos( "S", "%s : %d"%( tr( "TIEMPO_SEGUNDOS_JUGADA" ), self.tiempoJugada ) )

        self.pantalla.activaJuego( True, True )

        tp = "%d:%02d"%( self.tiempoTotal/60,self.tiempoTotal%60)
        bl, ng = self.jugador, self.rival
        if self.siRivalConBlancas :
            bl, ng = ng, bl
        self.pantalla.ponDatosReloj( bl, tp, ng, tp )

        self.pantalla.ponToolBar( ( k_rendirse,k_tablas,k_atras,k_reiniciar,k_otros ) )
        self.ponMensajero( self.mueveLocal )
        self.ponPosicion( self.partida.ultPosicion )
        self.mostrarIndicador( True )
        self.ponAyudasRemoto( )
        self.ponPiezasAbajo( siBlancas )
        self.pgnRefresh( True )

        self.siHechoPrimerMovimiento = False
        self.ultimoTMenviado = None
        self.estado = kJugando

        self.ponPosicionDGT()

        self.siguienteJugada()

    #--------------------------------------------------------------------------------------------------------------------------------
    def ponAyudasRemoto( self ) :
        self.pantalla.ponAyudas( self.ayudas, siAtras=False )
    #--------------------------------------------------------------------------------------------------------------------------------
    def quitaAyudasRemoto( self ) :
        self.pantalla.quitaAyudas( True, False )

    #--------------------------------------------------------------------------------------------------------------------------------
    def terminar( self ) :
        self.quitaCapturas()
        self.pantalla.quitaChat()
        self.pantalla.activaJuego(False,False)
        if self.socket :
            self.socket.close()
            if self.siServidor :
                if self.server :
                    self.server.close()
        self.procesador.inicio()

    #--------------------------------------------------------------------------------------------------------------------------------
    def finalX( self ) :
        if not self.siDesconectado :
            if self.estado == kJugando :
                return self.rendirse()
            else :
                self.terminar()
        return True

    #--------------------------------------------------------------------------------------------------------------------------------
    def dameTiempoGUI( self ) :
        if self.controlTiempo :
            t = self.tiempoTotal-self.tiempoUtilizado-( time.clock()-self.marcaTiempo )
        else :
            t = self.tiempoTotal-self.tiempoUtilizado
        if t <= 0.0 :
            return None

        segs = int(t)
        mins = segs/60
        segs = segs-mins*60

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

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

        if self.estado == kFinJuego :
            return

        self.estado = kJugando

        self.siJuegaLocal = False
        self.ponVista()

        siBlancas = self.partida.ultPosicion.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()

        if self.ayudas == 0 :
            self.quitaAyudasRemoto()
            self.siTutorActivado = False

        siRival = siBlancas == self.siRivalConBlancas

        if siRival :
            self.activaTB( False )
            self.tablero.desactivaTodas( )

        else :
            self.siJuegaLocal = True
            self.activaTB( True )
            if self.siTutorActivado :
                self.analizaTutor()
            self.tablero.activaColor( siBlancas ) # Que pueda mover el jugador

            self.relojStart()

    #--------------------------------------------------------------------------------------------------------------------------------
    def activaTB( self, siJuegaLocal ) :
        if self.partida.numJugadas() > 0 :
            for k in (k_tablas, k_rendirse,k_reiniciar) :
                self.pantalla.habilitaToolbar( k, siJuegaLocal )
            self.pantalla.habilitaToolbar( k_atras, not siJuegaLocal )
        else :
            for k in (k_tablas, k_rendirse,k_atras,k_reiniciar) :
                self.pantalla.habilitaToolbar( k, False )

    #--------------------------------------------------------------------------------------------------------------------------------
    def paraLocal(self) :
        self.siJuegaLocal = False
        self.desactivaTodas()

    #--------------------------------------------------------------------------------------------------------------------------------
    def sigueLocal(self) :
        self.siTeclaPanico = False
        self.siJuegaLocal = True
        self.activaColor( self.partida.ultPosicion.siBlancas )

    #--------------------------------------------------------------------------------------------------------------------------------
    def mueveLocal( self, desde, hasta ) :

        if self.siJuegaLocal :
            self.paraLocal()
        else :
            return False

        movimiento = desde + hasta

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

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

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

        if siBien :

            siMirarTutor = self.siTutorActivado

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

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

                        if tutor.elegir( self.ayudas > 0, self.configuracion.cTableroT ) :
                            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.sigueLocal()
                return False

            self.relojStop( True )

            self.movimientosPiezas( jg.liMovs )

            self.partida.ultPosicion = jg.posicion
            self.masJugada( jg )

            mens = Remoto.Mensaje()
            mens.nuevo( Remoto.MENS_JUGADA, jg.desde+"-"+jg.hasta+"-"+jg.coronacion )
            self.enlaceEnvio( mens )

            self.error = ""
            self.siguienteJugada()
            return True
        else :
            self.sigueLocal()
            self.error = mens
            return False

    #--------------------------------------------------------------------------------------------------------------------------------
    def masJugada( self, jg ) :
        if not self.siHechoPrimerMovimiento :
            self.siHechoPrimerMovimiento = 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.ponAyudasRemoto(  )

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

        self.ponPosicionDGT()

    #--------------------------------------------------------------------------------------------------------------------------------
    def mueveRival( self, desde, hasta, coronacion ) :
        self.refresh()

        siBien, mens, jg = Jugada.dameJugada( self.partida.ultPosicion, desde, hasta, coronacion )
        self.partida.ultPosicion = jg.posicion
        if self.ayudas :
            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.siguienteJugada()

    #-----------------------------------------------------------------------------------
    def analizaPosicion( self, fila, clave ) :
        siBlancas = clave != "NEGRAS"

        pos = fila*2
        if not siBlancas :
            pos += 1
        if self.partida.siEmpiezaConNegras :
            pos -= 1
        tam_lj = self.partida.numJugadas()
        if tam_lj == 0 :
            return
        siUltimo = (pos+1) >= tam_lj

        jg = self.partida.liJugadas[ pos ]

        if self.estado != kFinJuego :
            if siUltimo or self.ayudas == 0 :
                return
            maxRecursion = tam_lj -pos - 2
        else :
            maxRecursion = 9999

        Analisis.MuestraAnalisis( self.procesador, self.xtutor, jg, self.siJugamosConBlancas, maxRecursion, pos )

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

        self.estado = kFinJuego

        self.beepResultado( quien )

        nombreContrario = self.rival

        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)
        QTUtil2.mensaje( self.pantalla, mensaje )
        self.ponFinJuego( )

    #--------------------------------------------------------------------------------------------------------------------------------
    def ponFinJuego( self ) :
        self.estado = kFinJuego
        self.pantalla.ponTitulo()
        self.desactivaTodas()
        liOpciones = [ k_terminar ]
        if self.siServidor :
            liOpciones.append( k_nuevapartida )
        if self.partida.numJugadas() :
            liOpciones.insert( 2, k_otros )
        self.pantalla.ponToolBar( liOpciones )

    #--------------------------------------------------------------------------------------------------------------------------------
    def ponRelojJugador(self):
        tm = self.dameTiempoGUI()
        if tm is None :
            tm = "0:00"
            mens = Remoto.Mensaje()
            mens.nuevo( Remoto.MENS_PIERDETIEMPO, "1" )
            self.enlaceEnvio( mens )
            self.ponReloj( self.siJugamosConBlancas, tm )
            self.ponResultado( kGanaRivalTiempo )
            return

        else :

            # envía la información
            if self.ultimoTMenviado != tm :
                self.ponReloj( self.siJugamosConBlancas, tm )
                mens = Remoto.Mensaje()
                mens.nuevo( Remoto.MENS_RELOJ, tm )
                self.enlaceEnvio( mens )
                self.ultimoTMenviado = tm

    #--------------------------------------------------------------------------------------------------------------------------------
    def ponReloj(self, siBlancas, tm ) :
        if siBlancas :
            self.pantalla.ponRelojBlancas( tm )
        else :
            self.pantalla.ponRelojNegras( tm )
    #--------------------------------------------------------------------------------------------------------------------------------
    def relojStart( self ) :
        if self.siHechoPrimerMovimiento :
            self.marcaTiempo = time.clock()
            self.controlTiempo = True
        self.ponRelojJugador( )

    #--------------------------------------------------------------------------------------------------------------------------------
    def relojStop( self, siHechaJugada ) :
        if self.siHechoPrimerMovimiento :
            if self.estado == kJugando :
                if self.marcaTiempo :
                    self.tiempoUtilizado += time.clock() - self.marcaTiempo
                if siHechaJugada :
                    self.tiempoUtilizado -= self.tiempoJugada
                self.controlTiempo = False
                self.ponRelojJugador( )

    #--------------------------------------------------------------------------------------------------------------------------------
    def propone( self, mensaje, tipo ) :
        siAceptado = False
        if QTUtil2.pregunta( self.pantalla, mensaje ) :

            self.siGestionRutina = True # Que no haga el trabajo el enlaceTimer

            self.relojStop(False)
            self.tablero.hide()

            mens = Remoto.Mensaje()
            mens.nuevo( tipo, "1" )
            self.enlaceEnvio( mens )

            me = QTUtil2.mensEspera.inicio( self.pantalla, tr( "ESPERANDO_RESPUESTA" ), siCancelar = True )

            self.respuesta = None
            while not me.cancelado() :

                self.recibe()
                if self.siDesconectado :
                    break
                if self.respuesta :
                    siAceptado = self.respuesta == "S"
                    break

                time.sleep( 0.2 )

            me.final()
            self.tablero.show()
            if self.respuesta is None :
                self.relojStart()
            self.siGestionRutina = False
        return siAceptado

    #--------------------------------------------------------------------------------------------------------------------------------
    def proponeTablas( self ) :
        if self.propone( tr( "PROPONE_TABLAS" ), Remoto.MENS_TABLAS ) :
            self.ponResultado( kTablasAcuerdo )

    #--------------------------------------------------------------------------------------------------------------------------------
    def respuestaSolicitudTablas( self ) :
        resp = "S" if QTUtil2.pregunta( self.pantalla, tr("RESPONDE_TABLAS") ) else "N"
        mens = Remoto.Mensaje()
        mens.nuevo( Remoto.MENS_RESPUESTA, resp )
        self.enlaceEnvio( mens )

    #--------------------------------------------------------------------------------------------------------------------------------
    def proponeAtras( self ) :
        if self.propone( tr( "PROPONE_ATRAS" ), Remoto.MENS_ATRAS ) :
            self.anulaUltimoMovimiento(self.siJugamosConBlancas)

    #--------------------------------------------------------------------------------------------------------------------------------
    def respuestaSolicitudAtras( self ) :
        resp = "S" if QTUtil2.pregunta( self.pantalla, tr("RESPONDE_ATRAS") ) else "N"
        mens = Remoto.Mensaje()
        mens.nuevo( Remoto.MENS_RESPUESTA, resp )
        self.enlaceEnvio( mens )
        if resp == "S" :
            self.anulaUltimoMovimiento(self.siRivalConBlancas)

    #--------------------------------------------------------------------------------------------------------------------------------
    def proponeReiniciar( self ) :
        if self.propone( tr( "PROPONE_REINICIAR" ), Remoto.MENS_REINICIAR ) :
            self.partida.reset()
            self.nuevaPartida( self.reinicio )

    #--------------------------------------------------------------------------------------------------------------------------------
    def respuestaSolicitudReiniciar( self ) :
        resp = "S" if QTUtil2.pregunta( self.pantalla, tr("RESPONDE_REINICIAR") ) else "N"
        mens = Remoto.Mensaje()
        mens.nuevo( Remoto.MENS_RESPUESTA, resp )
        self.enlaceEnvio( mens )
        if resp == "S" :
            self.partida.reset()
            self.nuevaPartida( self.reinicio )

    #--------------------------------------------------------------------------------------------------------------------------------
    def rendirse( self ) :
        if QTUtil2.pregunta( self.pantalla, tr( "TE_RINDES" ) ) :
            mens = Remoto.Mensaje()
            mens.nuevo( Remoto.MENS_RENDIRSE, "1" )
            self.enlaceEnvio( mens )
            self.ponResultado( kGanaRival )

    #-----------------------------------------------------------------------------------
    def anulaUltimoMovimiento( self, siBlancas ) :
        self.partida.anulaUltimoMovimiento(siBlancas)
        self.tablero.ponPosicion( self.partida.ultPosicion )
        if self.partida.numJugadas() :
            jg = self.partida.liJugadas[-1]
            self.ponFlechaSC( jg.desde, jg.hasta )
        self.pantalla.pgnRefresh(siBlancas)
        self.controlTiempo = False
        self.ponRelojJugador( )
        self.siguienteJugada()

