#!/usr/bin/env python
# encoding: iso-8859-15
#
#Minë. Mundo Interactivo-Narrativo en Español [Tierra-Media]
#Copyright (C) 2002  Pablo Ruiz Múzquiz
#
#
#This program is free software; you can redistribute it and/or modify
#it under the terms of the GNU General Public License as published by
#the Free Software Foundation; either version 2 of the License, or
#(at your option) any later version.
#
#This program is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#GNU General Public License for more details.
#
#You should have received a copy of the GNU General Public License
#along with this program; if not, write to the Free Software
#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
#
#Fichero: DialogoNormal.py

"""Clase DialogoNormal."""

import logging
from logo import *
from utils import *
import Mundo
import Sala
import Dialogo
import Personaje
import PersonajeJugador
import Idioma
import FechaHoraMine
import ayuda

log = logging.getLogger("Dialogos")

COMANDOS_POSIBLES = ['+salir','+doc','+ip','+seguir','+noseguir','+hablar','+hablarq','+hablaro',
		     '+hablare', '+susurrar','+susurrarq','+susurrare','+susurraro','+gritar',
		     '+gritarq','+gritare','+gritaro','+idioma','+actuar','+decir','+preguntar',
		     '+atacar','+coger','+dejar','+esconder','+mochila','+examinar','+usar',
		     '+comer','+beber','+estadisticas','+mirar','+mr','+area','+observar',
		     '+silencio','+confiar','+noconfiar','+dar','+amigos','+recapitular','+reloj',
		     '+poner','+quitar','+pagar','+comprar']

COMANDOS_MAIAR =  ['+entorno','+ent','+listar','+localizar','+loc']

COMANDOS_DIRECCIONES = ['+norte', '+noreste', '+este', '+sureste', '+sur',
			'+suroeste', '+oeste', '+noroeste', '+arriba', '+abajo']

COMANDOS_ABREV_DIR = {'+n':'+norte',   '+ne':'+noreste',   '+e':'+este',  '+se':'+sureste',
		      '+s':'+sur',     '+so': '+suroeste', '+o':'+oeste', '+no':'+noroeste',
		      '+arr':'+arriba', '+ab':'+abajo'}


class DialogoNormal(Dialogo.Dialogo):
    """Dialogo principal del jugador, con la mayoría de los comandos.
    
    Contiene los siguientes atributos:
     - __personaje (PersonajeJugador): copia del personaje controlado.

    Invariantes:
      __personaje != None
    """

    def __init__(self, padre, conn, personaje):
        Dialogo.Dialogo.__init__(self, padre, conn)
        self.__personaje = personaje
        self.__inactivo = 0

        self.lanzar_tirada_percep_sala()
    
        self.cmd_estadisticas()

        self.conn().send('La apariencia de tu personaje es:')
        for item in self.__personaje.descripcion:
            self.conn().send(color(31) + item["texto"] + finl)
            self.conn().send('')

        self.cmd_mirar()

        self.conn().send("IMPORTANTE: los comandos se escriben empezando con el carácter +.")
        self.conn().send("Escribe +? para leer la ayuda.")
        self.conn().send("Para hablar, simplemente escribe algo sin + delante.")
        self.conn().send('')
        if self.__personaje.es_maia: self.conn().send("Eres un Maia de Minë.")
        self.conn().send('')
        self.estado_0()


    def lanzar_tirada_percep_sala(self):
	"""Método llamado cada vez que se entra en una sala nueva,
	para hacer la tirada."""
	self.__personaje.tirar_atributo("percepcion_sala", "inteligencia", 0)


    # -------------------------------------------
    # EVENTOS DE CONTROLADOR (ver Controlador.py)
    # -------------------------------------------

    def entra_personaje(self, personaje):
        if self.__personaje.silencio == "no":
	    if personaje.es_jugador:
                self.conn().send(color(35) + personaje.id + " ha entrado" + finl)
            else:
                self.conn().send(color(35) + personaje.nombre + " ha entrado" + finl)
                        
                        
    def sale_personaje(self, personaje, nombre_sala_destino):
        if self.__personaje.silencio == "no":
	    if personaje.es_jugador:
                self.conn().send(color(35) + personaje.id + " se va hacia " + 
                                 nombre_sala_destino + finl)
            else:
                self.conn().send(color(35) + personaje.nombre + " se va hacia " + 
                                 nombre_sala_destino + finl)
                        
                        
    def habla_personaje(self, personaje, mensaje):
	if personaje.es_jugador:
            self.conn().send('')
            self.conn().send(personaje.id + " dice: " + personaje.color_texto() + mensaje +'  ' + finl)
        else:
            self.conn().send('')
            self.conn().send(personaje.nombre + " dice: " + personaje.color_texto() + mensaje +'  ' + finl)

        
    def susurra_personaje(self, personaje, mensaje):
	if personaje.es_jugador:
            self.conn().send(personaje.id + " susurra: " + personaje.color_texto()  + mensaje + finl)
        else:
            self.conn().send(personaje.nombre + " susurra: " + personaje.color_texto()  + mensaje + finl)

        
    def grita_personaje(self, personaje, mensaje):
        if self.__personaje.silencio == "no":
	    if personaje.es_jugador:
                self.conn().send('')
                self.conn().send(color(35) + personaje.id + " grita: " + personaje.color_texto()  + mensaje + finl)
            else:
                self.conn().send('')
                self.conn().send(color(35) + personaje.nombre + " grita: " + personaje.color_texto()  + mensaje + finl)


    def actua_personaje(self, personaje, accion):
        if self.__personaje.silencio == "no":
	    if personaje.es_jugador:
                self.conn().send(personaje.id +  " " + accion)
            else:
                self.conn().send(personaje.nombre +  " " + accion)
 

    def actua_individual_personaje(self, personaje, accion):
	if personaje.es_jugador:
            self.conn().send(personaje.color_texto() + personaje.id + ' ' + accion + finl)
        else:
            self.conn().send(personaje.color_texto() + personaje.nombre + ' ' + accion + finl)
 
    
    def actua_uno_mismo(self, accion):
        self.conn().send(accion)
                      
                        
    def actua_global_personaje(self, personaje, accion):
        if self.__personaje.silencio == "no":
	    if personaje.es_jugador:
                self.conn().send(color(35) + personaje.id + " " + accion + finl)
            else:
                self.conn().send(color(35) + personaje.nombre + " " + accion + finl)
                        
                        
    def suceso_entorno(self, suceso):
        if self.__personaje.silencio == "no":
            self.conn().send('...'+ suceso + '...')
        
    
    def ataca_personaje(self, personaje, result):
        # Llamar a la función correspondiente según estado
        nombre_func = "ataque_" + self.estado
        if self.sub_estado != None: nombre_func += "_" + str(self.sub_estado)
        
        func = getattr(self, nombre_func, None)
        if func == None:
                  ((self.sub_estado != None and "_" + str(self.sub_estado)) or "") + \
                  ((self.personaje != None and  "(" + self.personaje.id + ")") or "")
        else:
            func(personaje, result)


    def movimiento_automatico(self):
        self.conn().send("Te mueves siguiendo a " + self.__personaje.anterior.id)
        self.lanzar_tirada_percep_sala()
        self.cmd_mirar()

        if self.__personaje.salas_visitadas.get(self.__personaje.sala.id) != 'si':
            self.conn().send("Es la primera vez que estás aquí...")
            self.__personaje.salas_visitadas.update({self.__personaje.sala.id:'si'})
            #Ganamos un punto de experiencia (hay que premiar la exploración)
	    self.__personaje.cambiar_experiencia(+1)
                        
                        
    def paga_personaje(self, personaje, monedas):
	if personaje.es_jugador:
            self.conn().send('')
            self.conn().send(personaje.id + " te ha pagado " + str(monedas) + " monedas")
        else:
            self.conn().send('')
            self.conn().send(personaje.nombre + " te ha pagado " + str(monedas) + " monedas")


    # -------------------
    # ESTADOS DEL DIALOGO
    # -------------------

    def estado_0(self):
        self.poner_estado(0)
        self.conn().send(color(33)+'? ' + finl, 0)
        

    def comando_0(self, cmd_list):
        """
        Esta función se encarga de preparar el input introducido
        en una serie de comandos independientes si procede.
        """
        if len(cmd_list) == 0:
            accion = ''
            args = []
            self.ejecutar(accion, args)
        else:
            acciones_temp = ' '.join(cmd_list)
            acciones = acciones_temp.split('&&')[:]
            for una_accion in acciones:
                una_accion = una_accion.split()
                accion = una_accion[0]
                try:
                    args = una_accion[1:]
                except:
                    args = [] 
                
                self.ejecutar(accion, args)


    def tick_0(self, tick_ahora, tick_anterior):
        """Durante el diálogo normal, los ticks del reloj se usan para ir 'cantando'
        el tiempo, como los serenos.
        """
        if tick_ahora.hora() != tick_anterior.hora():
            self.conn().send(color(35) + "El tiempo pasa. Son las %d horas (%s)." %
                                         (tick_ahora.hora(), tick_ahora.desc_seccion()) + finl)
            # Desconexión automática si el jugador está una hora de juego sin hacer nada
            # Para evitar que el personaje muera de hambre si la conexión se queda abierta
            if self.__inactivo:
                self.conn().send("Llevas más de una hora de juego sin actividad.")
                self.conn().send("Has sido desconectado automáticamente para garantizar la seguridad de tu personaje.")
                self.conn().send("Puedes volver a conectarte en cualquier momento.")
                self.estado_1()
            self.__inactivo = 1
            
            
    def ataque_normal_0(self, personaje, result):
        # Al recibir un ataque, pasamos inmediantamente a estado combate.
        
        self.oponente = personaje
        self.cbt_empieza_combate_defiendes()
        self.cbt_te_pegan(result)
        
        if (self.__personaje.estado == "muerto") or (self.oponente.estado == "muerto"):
            self.cbt_termina_combate()
            self.estado_0()
        else:
            # Al poner un crono de 3 segundos, el combate funciona como
            # una sucesion de golpes alternados cada 3 segundos.
            self.lanzar_crono(3)
            self.estado_combate_1()
        

    def estado_1(self):
        self.padre().desconectar()


    # --------------------
    # "PARSER" DE COMANDOS
    # --------------------

    def ejecutar(self, accion, args):

        #Debido a la necesidad de loggear la actividad
        #se escribe tanto en pantalla como en el fichero de log
        #la orden dada.
        comando_dado = ' '.join([self.__personaje.nombre+' ejecuta: ',accion,' '.join(args)])
        log.info(comando_dado)
        self.__inactivo = 0

        try:

            # Primero se ve si el comando es en realidad una de las
            # posibles direcciones.  Notar que la direccion "otro" no aparece en
            # esta lista (si alguna sala tiene una  salida en esta direccion, hay
            # que usar el id de la salida para moverse a ella).
            
            es_salida = 0

            if accion in COMANDOS_DIRECCIONES:
                es_salida = 1
                direccion = accion[1:]
            elif accion in COMANDOS_ABREV_DIR.keys():
                es_salida = 1
                direccion = COMANDOS_ABREV_DIR[accion][1:]

            if es_salida == 1:
                encontrado = 0

                for salida in self.__personaje.sala.salidas:
                    if direccion == salida["direccion"] and \
                        self.__personaje.resultado_tirada("percepcion_sala", salida["dificultad"]) > 0:
                        encontrado = 1
                        self.cmd_mover(salida["id"])
                        #En cuanto hayamos encontrado una sala que esté en esa dirección
                        #nos vamos a ella. De otra forma, Minë te presenta todas, una por una
                        #y te deja en la última del búcle
                        break
                        
                if encontrado == 0:
                    self.conn().send("No puedes ir por ahi.")

                self.estado_0()

            # Si no, ver si es el id de una de las salidas.
            if es_salida == 0:
                for salida in self.__personaje.sala.salidas:
                    if normalizar_id(accion[1:]) == extraer_id(salida["descripcion"]) and \
		      self.__personaje.resultado_tirada("percepcion_sala", salida["dificultad"]) > 0:
                        es_salida = 1
                        self.cmd_mover(salida["id"])
                        self.estado_0()

            # Si no, ver si es un comando. En ese caso, llamar a la función
            # especializada en ejecutar cada comando.
            if es_salida == 0:

                #Comprobamos que un jugador normal no intenta ejecutar una acción de Maia
                if accion in COMANDOS_MAIAR and self.__personaje.es_maia == 0:
                    self.conn().send("Error, comando no reconocido. Escribe '+?' y pulsa ENTER")
                    self.conn().send("para una lista de comandos.")
                    self.estado_0()

                #Miramos cada acción por separado.
                
                elif accion == "+decir":
                    self.cmd_hablar_pnj("decir", args)
                    self.estado_0()
                    
                elif accion == "+preguntar" or accion == "+p":
                    self.cmd_hablar_pnj("preguntar", args)
                    self.estado_0()
                    
                elif accion == "+recapitular" or accion == "+recap":
                    self.cmd_recapitular(args)
                    self.estado_0()
                    
                elif accion == "+creditos":
                    for linea in creditos.splitlines():
                        self.conn().send(linea)
                    self.estado_0()

                elif accion == "+sus" or accion == "+susurrar":
                    try:
                        oyente = args[0]
                        mensaje = " ".join(args[1:])
                        self.cmd_susurrar(oyente, mensaje, idioma=self.__personaje.idioma_base)
                    except:
                        self.conn().send('Tienes que decir algo a alguien')
                        self.estado_0()
                    self.estado_0()

                elif accion == "+susq" or accion == "+susurrarq":
                    try:
                        oyente = args[0]
                        mensaje = " ".join(args[1:])
                        self.cmd_susurrar(oyente, mensaje, idioma=Idioma.quenya)
                    except:
                        self.conn().send('Tienes que decir algo a alguien')
                        self.estado_0()
                    self.estado_0()

                elif accion == "+suse" or accion == "+susurrare":
                    try:
                        oyente = args[0]
                        mensaje = " ".join(args[1:])
                        self.cmd_susurrar(oyente, mensaje, idioma=Idioma.enano)
                    except:
                        self.conn().send('Tienes que decir algo a alguien')
                        self.estado_0()
                    self.estado_0()

                elif accion == "+suso" or accion == "+susurraro":
                    try:
                        oyente = args[0]
                        mensaje = " ".join(args[1:])
                        self.cmd_susurrar(oyente, mensaje, idioma=Idioma.orco)
                    except:
                        self.conn().send('Tienes que decir algo a alguien')
                        self.estado_0()
                    self.estado_0()

                elif accion == "+h" or accion == "+hablar":
                    mensaje = " ".join(args)
                    self.cmd_hablar(mensaje, idioma=Idioma.oestron)
                    self.estado_0()
                    
                elif accion == "+hq" or accion == "+hablarq":
                    mensaje = " ".join(args)
                    self.cmd_hablar(mensaje, idioma=Idioma.quenya)
                    self.estado_0()

                elif accion == "+he" or accion == "+hablare":
                    mensaje = " ".join(args)
                    self.cmd_hablar(mensaje, idioma=Idioma.enano)
                    self.estado_0()

                elif accion == "+ho" or accion == "+hablaro":
                    mensaje = " ".join(args)
                    self.cmd_hablar(mensaje, idioma=Idioma.orco)
                    self.estado_0()

                elif accion == "+g" or accion == "+gritar":
                    mensaje = " ".join(args)
                    self.cmd_gritar(mensaje)
                    self.estado_0()
                    
                elif accion == "+gq" or accion == "+gritarq":
                    mensaje = " ".join(args)
                    self.cmd_gritar(mensaje, idioma=Idioma.quenya)
                    self.estado_0()

                elif accion == "+ge" or accion == "+gritare":
                    mensaje = " ".join(args)
                    self.cmd_gritar(mensaje, idioma=Idioma.enano)
                    self.estado_0()

                elif accion == "+go" or accion == "+gritaro":
                    mensaje = " ".join(args)
                    self.cmd_gritar(mensaje, idioma=Idioma.orco)
                    self.estado_0()

                elif accion == "+est" or accion == "+estadisticas":
                    self.cmd_estadisticas()
                    self.estado_0()

                elif accion == "+m" or accion == "+mirar":
                    self.cmd_mirar()
                    self.estado_0()

                elif accion == "+mr":
                    self.cmd_mirar(resumen=1)
                    self.estado_0()

                elif accion == "+mochila" or accion == "+mo":
                    self.cmd_mochila()
                    self.estado_0()

                elif accion == "+silencio":
                    self.cmd_silencio()
                    self.estado_0()
                    
                elif accion == "+idioma":
                    nombre_idioma_base = (len(args) > 0 and args[0]) or ""
                    self.cmd_idioma(nombre_idioma_base)
                    self.estado_0()
                    
                elif accion == "+c" or accion == "+coger":
                    (id_objeto, cantidad, n_orden, n_instancia, ok) = \
                        self.parsear_ident_objeto(args, "coger")
                    if ok:
                        self.cmd_coger(id_objeto, cantidad, n_orden, n_instancia)
                    self.estado_0()
    #%%                try:
    #%%                    nombre_objeto = (len(args) > 0 and args[0]) or ""
    #%%                    cantidad = int((len(args) > 1 and args[1])) or 1
    #%%                    if cantidad > 50:
    #%%                        cantidad = 50
    #%%                        self.conn().send("No se permite coger más de 50 objetos por vez.")
    #%%                    self.cmd_coger(nombre_objeto,cantidad)
    #%%                    self.estado_0()
    #%%                except:
    #%%                    self.conn().send('Ha ocurrido un error. Consulta la sintaxis del comando en la ayuda con +?')
    #%%                    self.estado_0()

                elif accion == "+d" or accion == "+dejar":
                    (id_objeto, cantidad, n_orden, n_instancia, ok) = \
                        self.parsear_ident_objeto(args, "dejar")
                    if ok:
                        self.cmd_dejar(id_objeto, cantidad, n_orden, n_instancia)

                    self.estado_0()
                        
                elif accion == "+esc" or accion == "+esconder":
                    (id_objeto, cantidad, n_orden, n_instancia, ok) = \
                        self.parsear_ident_objeto(args, "esconder")
                    if ok:
                        dificultad = self.__personaje.generar_dificultad("inteligencia", 0)
                        self.cmd_dejar(id_objeto, cantidad, n_orden, n_instancia, dificultad)

                    self.estado_0()

    #%%                try:
    #%%                    nombre_objeto = (len(args) > 0 and args[0]) or ""
    #%%                    cantidad = int((len(args) > 1 and args[1])) or 1
    #%%                    self.cmd_dejar(nombre_objeto, cantidad, accion = "escondido", dif=self.__personaje.atrib["inteligencia"])
    #%%                    self.estado_0()
    #%%                except:
    #%%                    self.conn().send('Ha ocurrido un error. Consulta la sintaxis del comando en la ayuda con +?')
    #%%                    self.estado_0()                

                elif accion == "+dar":
                    (id_receptor, id_objeto, cantidad, n_orden, n_instancia, ok) = \
                        self.parsear_ident_objeto(args, "dar")
                    if ok:
                        self.cmd_dar(id_receptor, id_objeto, cantidad, n_orden, n_instancia)

                    self.estado_0()
                   
                elif accion == "+comer":
                    (id_objeto, cantidad, n_orden, n_instancia, ok) = \
                        self.parsear_ident_objeto(args, "comer")
                    if ok:
                        if cantidad > 1:
                            self.conn().send("El comando no es correcto, consulta la ayuda con +?")
                        else:
                            self.cmd_comer(id_objeto, n_orden, n_instancia)

                    self.estado_0()
                   
                elif accion == "+beber":
                    (id_objeto, cantidad, n_orden, n_instancia, ok) = \
                        self.parsear_ident_objeto(args, "beber")
                    if ok:
                        if cantidad > 1:
                            self.conn().send("El comando no es correcto, consulta la ayuda con +?")
                        else:
                            self.cmd_beber(id_objeto, n_orden, n_instancia)

                    self.estado_0()
                   
                elif accion == "+u" or accion == "+usar":
                    (id_objeto, cantidad, n_orden, n_instancia, id_objeto2, n_orden2, \
                        n_instancia2, ok) = self.parsear_ident_objeto(args, "usar")
                    if ok:
                        if cantidad > 1:
                            self.conn().send("El comando no es correcto, consulta la ayuda con +?")
                        else:
                            if id_objeto2 == "":
                                self.cmd_usar(id_objeto, n_orden, n_instancia)
                            else:
                                self.cmd_usar_con(id_objeto, n_orden, n_instancia,
                                                  id_objeto2, n_orden2, n_instancia2)

                    self.estado_0()

    #%%                nombre_objeto = (len(args) > 0 and args[0]) or ""
    #%%                self.cmd_usar(nombre_objeto)
    #%%                self.estado_0()

                elif accion == "+poner":
                    if len(args) == 0:
                        self.conn().send("Debes indicar la posición y el objeto a ponerte, consulta la ayuda con +?")
                    else:
                        posicion = args[0]
                        if not posicion in Personaje.POSICIONES:
                            self.conn().send("La posición no es válida, consulta la ayuda con +?")
                        else:
                            (id_objeto, cantidad, n_orden, n_instancia, ok) = \
                                self.parsear_ident_objeto(args[1:], "poner")
                            if ok:
                                if cantidad > 1:
                                    self.conn().send("El comando no es correcto, consulta la ayuda con +?")
                                else:
                                    self.cmd_poner(posicion, id_objeto, n_orden, n_instancia)

                    self.estado_0()

                elif accion == "+quitar":
                    if len(args) == 0:
                        self.conn().send("Debes indicar la posición, consulta la ayuda con +?")
                    else:
                        posicion = args[0]
                        if not posicion in Personaje.POSICIONES:
                            self.conn().send("La posición no es válida, consulta la ayuda con +?")
                        else:
                            self.cmd_quitar(posicion)

                    self.estado_0()

                elif accion == "+confiar":
                    id_personaje_de_confianza = args[0]
                    self.__personaje.ids_amigos.update({id_personaje_de_confianza:1})
                    self.conn().send("A partir de ahora confías en "+id_personaje_de_confianza)

                    self.estado_0()
                    
                elif accion == "+noconfiar":
                    id_personaje_de_no_confianza = args[0]
                    self.__personaje.ids_amigos.update({id_personaje_de_no_confianza:0})
                    self.conn().send("A partir de ahora no confías en "+id_personaje_de_no_confianza)

                    self.estado_0()

                elif accion == "+amigos":
                    self.cmd_listar_amigos()
                    self.estado_0()

                elif accion == "+ex" or accion == "+examinar":
                    (id_objeto, cantidad, n_orden, n_instancia, ok) = \
                        self.parsear_ident_objeto(args, "examinar")
                    if ok:
                        if cantidad > 1:
                            self.conn().send("El comando no es correcto, consulta la ayuda con +?")
                        else:
                            self.cmd_examinar(id_objeto, n_orden, n_instancia)

                    self.estado_0()

    #%%                nombre_objeto = (len(args) > 0 and args[0]) or ""
    #%%                posicion = int((len(args) > 1 and args[1])) or 1
    #%%                if posicion < 1: posicion = 1
    #%%                self.cmd_examinar(nombre_objeto,posicion)
    #%%                self.estado_0()

                elif accion == "+ob" or accion == "+observar":
                    nombre_oponente = (len(args) > 0 and args[0]) or ""
                    self.cmd_observar(nombre_oponente)
                    self.estado_0()

                elif accion == "+a" or accion == "+atacar":
                    self.conn().send("Comando deshabilitado temporalmente. Lo sentimos.")
                    self.estado_0()

                elif accion == "+sal" or accion == "+salir" or accion == "/q" or accion == "+q":
                    self.estado_1()

                elif accion == "+":
                    self.estado_0()
                    
                elif accion == "+help" or accion == "+ayuda" or accion == "+?":
                    self.cmd_ayuda(args)
                    self.estado_0()

                elif accion == "+doc":
                    self.cmd_doc(args)
                    self.estado_0()

                elif accion == "+actuar" or accion == "+act":
                    mensaje = " ".join(args)
                    self.cmd_actuar(mensaje)
                    self.estado_0()
                    
                elif accion == "+entorno" or accion == "+ent":
                    mensaje = " ".join(args)
                    self.cmd_entorno(mensaje)
                    self.estado_0()
                    
                elif accion == "+listar":
                    self.cmd_listar_personajes()
                    self.estado_0()
                    
                elif accion == "+localizar" or accion == "+loc":
                    try:
                        self.cmd_localizar(args[0])
                    except:
                        self.conn().send('Tienes que especificar un personaje para localizar')

                    self.estado_0()

                elif accion == "+seguir" or accion == "+seg":
                    if len(args) == 0:
                        self.conn().send('Tienes que especificar un personaje para seguir')
                    else:
                        self.cmd_seguir(args[0])
                    self.estado_0()

                elif accion == "+noseguir" or accion == "+noseg":
                    self.cmd_no_seguir()
                    self.estado_0()

                elif accion == "+ip":
                    self.cmd_ip()
                    self.estado_0()

                elif accion == "+area":
                    self.cmd_area()
                    self.estado_0()

                elif accion == "+reloj":
                    self.cmd_reloj()
                    self.estado_0()

		elif accion == "+pagar":
		    if len(args) < 1:
                        self.conn().send('Tienes que decir a quien quieres pagar')
		    elif len(args) < 2:
                        self.conn().send('Tienes que decir cuanto quieres pagar')
		    else:
			try:
			    nombre_otro_personaje = args[0]
			    monedas = int(args[1])
			    self.cmd_pagar(nombre_otro_personaje, monedas)
			except ValueError:
			    self.conn().send('La cantidad de monedas debe ser un número')
		    self.estado_0()

                elif accion == "+comprar":
                    (id_objeto, cantidad, n_orden, n_instancia, ok) = \
                        self.parsear_ident_objeto(args, "comprar")
                    if ok:
                        self.cmd_comprar(id_objeto, cantidad, n_orden, n_instancia)

                    self.estado_0()

                elif accion == "":
                    self.estado_0()

                elif accion[0] == "+" or accion == "+":
                    self.conn().send("Error, comando no reconocido. Escribe '+?' y pulsa ENTER")
                    self.conn().send("para una lista de comandos.")
                    self.estado_0()
                    
                else:
                    mensaje = accion + ' ' + " ".join(args)
                    self.cmd_hablar(mensaje, idioma=self.__personaje.idioma_base)
                    self.estado_0()

        except ExcepcionDeJuego, ex:

            self.conn().send(str(ex))
            self.estado_0()


    def parsear_ident_objeto(self, args, comando):
        """Pequeña funcion utilitaria para parsear la secuencia
        [<id_receptor>] [<cantidad>] id_objeto [<n_orden>] [<n_instancia>] \
        [ +con id_objeto2 [<n_orden2>] [<n_instancia2>] ].

        cantidad, n_orden y n_instancia se reconocen porque son sólo dígitos.
        id_objeto puede tener más de una palabra.
        id_receptor sólo puede tener una palabra.
        id_receptor sólo se parsea si el comando es "dar"
        Los elementos detrás de +con sólo se parsean si el comando es "usar"
        """
        id_receptor = ""
        cantidad = 1
        id_objeto = ""
        n_orden = 1
        n_instancia = 1
        id_objeto2 = ""
        n_orden2 = 1
        n_instancia2 = 1
        ok = 1

        i = 0

        if (comando == 'dar') \
	   and i < len(args) and not args[i].isdigit():
            id_receptor = args[i]
            i = i + 1
        
        if i < len(args) and args[i].isdigit():
            cantidad = int(args[i])
            i = i + 1

        while i < len(args) and not args[i].isdigit() and args[i] != "+con":
            if len(id_objeto) > 0:
                id_objeto += " "
            id_objeto += args[i]
            i = i + 1

        if i < len(args) and args[i].isdigit():
            n_orden = int(args[i])
            i = i + 1

        if i < len(args) and args[i].isdigit():
            n_instancia = int(args[i])
            i = i + 1

        if id_objeto == "":
            self.conn().send("Tienes que indicar qué objeto quieres " + comando + ".")
            ok = 0
        elif cantidad < 1:
            self.conn().send("La cantidad tiene que ser igual o mayor que 1.")
            ok = 0
        elif n_orden < 1:
            self.conn().send("El número de orden tiene que ser igual o mayor que 1.")
            ok = 0
        elif n_instancia < 1:
            self.conn().send("El número de objeto tiene que ser igual o mayor que 1.")
            ok = 0

        if ok and i < len(args):
            if comando != 'usar' or args[i] != '+con':

                self.conn().send("El comando no es correcto, consulta la ayuda con +?")
                ok = 0

            else:

                i = i + 1

                while i < len(args) and not args[i].isdigit():
                    if len(id_objeto2) > 0:
                        id_objeto2 += " "
                    id_objeto2 += args[i]
                    i = i + 1

                if i < len(args) and args[i].isdigit():
                    n_orden2 = int(args[i])
                    i = i + 1

                if i < len(args) and args[i].isdigit():
                    n_instancia2 = int(args[i])
                    i = i + 1

                if id_objeto2 == "":
                    if n_orden2 < 1:
                        self.conn().send("El número de orden 2 tiene que ser igual o mayor que 1.")
                        ok = 0
                    elif n_instancia2 < 1:
                        self.conn().send("El número de objeto 2 tiene que ser igual o mayor que 1.")
                        ok = 0
                
        if comando == 'dar':
            return (id_receptor, id_objeto, cantidad, n_orden, n_instancia, ok)
        elif comando == 'usar':
            return (id_objeto, cantidad, n_orden, n_instancia, id_objeto2, n_orden2, n_instancia2, ok)
        else:
            return (id_objeto, cantidad, n_orden, n_instancia, ok)


    # ---------------------
    # EJECUCION DE COMANDOS
    # ---------------------

    def cmd_doc(self,args):
	self.conn().send("")
        self.conn().send(color(32) + "--------- Documentación de Minë ---------" + finl)
	self.conn().send("")
        if len(args) > 0:
            
            if args[0] == "instalacion" or args[0] == "inst":
                
                self.conn().send(ayuda.como_instalar_mine)
            
                
            elif args[0] == "tolkien" or args[0] == "jrrt":
                
                self.conn().send(ayuda.tolkien)
            
                
            elif args[0] == "gpl" or args[0] == "gnu":
                
                self.conn().send(ayuda.gpl)

        else:
            self.conn().send("Los documentos disponibles actualmente son:")
            self.conn().send("")
            self.conn().send("[ instalacion | tolkien | gpl ]")

            
    def cmd_ayuda(self,args):

      self.conn().send("")
      self.conn().send(color(32) + "------------------------ Ayuda de Minë ------------------------" + finl)
      self.conn().send("Las letras en corchete y las letras tras el signo '/' indican")
      self.conn().send("una abreviatura alternativa válida para la orden")
      self.conn().send("")
      if len(args) > 0:

          if args[0] == "movimiento":

              self.conn().send(color(33) + " Movimiento" + finl)
	      self.conn().send("")
              self.conn().send("Moverse a otra sala, hay tres posibilidades: ")
              self.conn().send("- Direccion (" + color(31) + "+norte" + finl + ", " + 
                               color(31) + "+sur" + finl + ", " +
                               color(31) + "+este" + finl + ", ")
              self.conn().send("             " + color(31) + "+oeste" + finl + ", " +
                               color(31) + "+noreste" + finl + ", " +
                               color(31) + "+noroeste" + finl + ", ")
              self.conn().send("             " + color(31) + "+sureste" + finl + ", " +
                               color(31) + "+suroeste" + finl + ", ")
              self.conn().send("             " + color(31) + "+arriba" + finl + ", " +
                               color(31) + "+abajo" + finl + ")")
              self.conn().send("- Abreviatura (" + color(31) + "+n" + finl + ", "+
                               color(31) + "+s" + finl + ", " +
                               color(31) + "+e" + finl + ", " +
                               color(31) + "+o" + finl + ", ")
              self.conn().send("               " + color(31) + "+ne" + finl + ", " +
                               color(31) + "+no" + finl + ", " +
                               color(31) + "+se" + finl + ", ")
              self.conn().send("               " + color(31) + "+so" + finl + ", " +
                               color(31) + "+arr" + finl + ", " +
                               color(31) + "+ab" + finl + ")")
              self.conn().send("- Palabra entre corchetes (" + color(31) + "+casa" + finl + ")")
              self.conn().send("  'Hacia el sur ves una [casa] vieja'")
              self.conn().send("")
              self.conn().send("Seguir a otro personaje para moverse con el")
              self.conn().send("   " + color(31) + "+[seg]uir <nombre>" + finl)
              self.conn().send("Dejar de seguir a otro personaje")
              self.conn().send("   " + color(31) + "+[noseg]uir" + finl)
              
          elif args[0] == "general":
              
              self.conn().send(color(33) + " General" + finl)
	      self.conn().send("")
              self.conn().send(" +[sal]ir     :Salir del juego")
              self.conn().send(" +doc         :Documentos de Minë")
              self.conn().send(" +ip          :Dirección IP del cliente")
              self.conn().send('')
              
          elif args[0] == "objetos":
              
              self.conn().send(color(33) + " Objetos" + finl)                    
	      self.conn().send("")
              self.conn().send(" Coger un objeto de la sala y meterlo en la mochila:")
              self.conn().send(color(31) + '  +[c]oger [<cantidad>] <id_objeto> [<n_orden> [<n_unidad>]]' + finl)
              self.conn().send(" Dejar un objeto de la mochila en la sala:")
              self.conn().send(color(31) + '  +[d]ejar [<cantidad>] <id_objeto> [<n_orden> [<n_unidad>]]' + finl)
              self.conn().send(" Esconder un objeto de la mochila en la sala:")
              self.conn().send(color(31) + '  +[esc]onder [<cantidad>] <id_objeto> [<n_orden> [<n_unidad>]]' + finl)
              
              self.conn().send(" Dar un objeto a alguien en la sala:")
              self.conn().send(color(31) + '  +dar <nombre> [<cantidad>] <id_objeto> [<n_orden> [<n_unidad>]]' + finl)
              
              self.conn().send(" Mirar el contenido de la mochila:")
              self.conn().send(color(31) + '  +[mo]chila' + finl)
              
              self.conn().send(" Examinar un objeto de la mochila:")
              self.conn().send(color(31) + '  +[ex]aminar <nombre> [<n_orden> [<n_unidad>]]' + finl)
              
              self.conn().send(" Usar un objeto de la mochila (opcionalmente con otro en mochila o sala):")
              self.conn().send(color(31) + '  +[u]sar <nombre> [<n_orden> [<n_unidad>]]')
              self.conn().send(            '    [+con <nombre> [<n_orden> [<n_unidad>]]]' + finl)
              
              self.conn().send("")
              
              self.conn().send(" -> el identificador del objeto es la primera palabra de su nombre, o la")
              self.conn().send("    palabra que haya entre corchetes.")
              
              self.conn().send(" -> si en la sala hay varios objetos DIFERENTES pero con el mismo id,")
              self.conn().send("    puedes indicar cual quieres con el parametro n_orden (1 el primero,")
              self.conn().send("    2 el segundo...)")
              
              self.conn().send(" -> si en la sala hay varias unidades del MISMO objeto (la cantidad de")
              self.conn().send("    unidades se indica entre parentesis detras de la descripcion del objeto),")
              self.conn().send("    puedes indicar cual quieres con el parametro n_unidad.")
              
              self.conn().send("")
              self.conn().send("  ej. si en la sala hay")
              self.conn().send("      - una espada")
              self.conn().send("      - una botella de [vino] (3)")
              self.conn().send("      - una botella de [cerveza]")
              self.conn().send("      - una jarra de [cerveza] (5)")
              
              self.conn().send("")
              self.conn().send("  +coger espada -> coge una espada")
              self.conn().send("  +coger 2 vino -> coge dos botellas de vino")
              self.conn().send("  +coger cerveza 2 -> coge una jarra de cerveza")
              self.conn().send("  +coger cerveza 2 3 -> coge la tercera jarra de cerveza")
              
              
          elif args[0] == "otros":
              
              self.conn().send(color(33) + " Otros" + finl)              
	      self.conn().send("")
              self.conn().send("Mostrar estadísticas de un personaje: " + 
                               color(31) + '+[est]adisticas' + finl)
              self.conn().send("Actuar en la sala: " +
                               color(31) + '+[act]uar <texto>' + finl)
              
              self.conn().send("Mirar la sala actual: " + 
                               color(31) + '+[m]irar' + finl)
              self.conn().send("Mirar la sala actual de forma resumida: " + 
                               color(31) + '+mr' + finl)
              
              self.conn().send("Nombre del área en la que te encuentras: " + 
                               color(31) + '+area' + finl)
              
              self.conn().send("Observar a un personaje: " +                             
                               color(31) + '+[ob]servar <personaje>' +finl)
              
              self.conn().send("Confiar en un personaje (necesario para recibir objetos): " +
                               color(31) + '+confiar <personaje>' +finl)
              
              self.conn().send("Dejar de confiar en un personaje (rechazas propuestas personales): " +
                               color(31) + '+noconfiar <personaje>' +finl)
              
              self.conn().send("Listas personas de confianza: " +                             
                               color(31) + '+amigos' +finl)
              
              self.conn().send("Limitar el texto recibido sí/no: " +
                               color(31) + '+silencio' + finl)
              
              self.conn().send("Mostrar la fecha y hora en Minë: " +
                               color(31) + '+reloj' + finl)
              
              self.conn().send("Localizar a un personaje (Sólo Maiar): " +
                               color(31) + '+[loc]alizar <nombre>' + finl)

              self.conn().send("Lista de jugadores de Minë (Sólo Maiar): " +
                               color(31) + '+listar' + finl)
              
          elif args[0] == "hablar":            
              
              self.conn().send(color(33) + " Hablar" + finl)
	      self.conn().send("")
              self.conn().send("Hablar en oestron en la sala actual: " +
                               color(31) + '+[h]ablar <texto>' + finl)
              self.conn().send("en quenya: " + 
                               color(31) + '+hablarq/hq <texto>' + finl)
              self.conn().send("en enano: " + 
                               color(31) + '+hablare/he <texto>' + finl)
              self.conn().send("en orco: " + 
                               color(31) + '+hablaro/ho <texto>' + finl)
              
              self.conn().send("Susurrar en oestron a alguien en la sala actual:")
              self.conn().send(color(31) + '  +[sus]urrar <nombre> <texto>' + finl)
              self.conn().send("en quenya:")
              self.conn().send(color(31) + '  +susurrarq/susq <nombre> <texto>' + finl)
              self.conn().send("en enano:")
              self.conn().send(color(31) + '  +susurrare/suse <nombre> <texto>' + finl)
              self.conn().send("en orco:")
              self.conn().send(color(31) + '  +susurraro/suso <nombre> <texto>' + finl)
              
              self.conn().send("Gritar en oestron a todo el mundo: " + 
                               color(31) + '+[g]ritar <texto>' + finl)
              self.conn().send("en quenya: " + 
                               color(31) + '+gritarq/gq <texto>' + finl)
              self.conn().send("en enano: " + 
                               color(31) + '+gritare/ge <texto>' + finl)
              self.conn().send("en orco: " + 
                               color(31) + '+gritaro/go <texto>' + finl)
              self.conn().send("Elegir idioma por defecto: " +
                               color(31) + "+idioma <idioma>" + finl)
              self.conn().send("Describir sucesos del entorno (Sólo Maiar): " +
                               color(31) + '+[ent]orno <texto>' + finl)

              self.conn().send("Entablar una conversación con un PNJ: " +
                               color(31) + '+decir <pnj> <texto>' + finl)
              self.conn().send("Preguntar al PNJ por un tema: " +
                               color(31) + '+[p]reguntar <pnj> <texto>' + finl)
              self.conn().send("Recordar los temas hablados con un PNJ: " +
                               color(31) + '+[recap]itular <pnj>' + finl)
             
          elif args[0] == "ataque":
              
              self.conn().send(color(33) + " Ataque" + finl)              
	      self.conn().send("")
              self.conn().send("Atacar a un personaje [deshabiltado]: " + 
                               color(31) + '+[a]tacar <nombre>' + finl)
              
          else:
              
              self.conn().send("Categoría de comandos no reconocida. Escribe '+?'.")
              
      else:
              
          self.conn().send("Debido al gran número de acciones que puede realizar un")
          self.conn().send("personaje, las hemos agrupado en diferentes categorías a las")
          self.conn().send("que puedes llamar con '+? [categoria]'.")
          
	  self.conn().send("")
          self.conn().send(color(31) + "Categorías de comandos:n" + finl)
	  self.conn().send("")
          
          self.conn().send(color(33),0)
          self.conn().send(" general      :%s" % ('Órdenes básicas de Minë'))
          self.conn().send(" movimiento   :%s" % ('Movimiento de PJs'))
          self.conn().send(" hablar       :%s" % ('Comunicación entre PJs y PNJs'))
          self.conn().send(" ataque       :%s" % ('Combate y defensa entre PJs y PNJs'))
          self.conn().send(" objetos      :%s" % ('Manejo de objetos'))
          self.conn().send(" otros        :%s" % ('Otras órdenes'))
          self.conn().send(finl)                                                         
          
          self.conn().send("Si lo que deseas es leer la documentación disponible acerca de Minë,")
          self.conn().send("entonces escribe '+doc' en la línea de comandos.")
	  self.conn().send("")
          
            
    def cmd_recapitular(self, argumentos):

        if len(argumentos) != 1:
            self.conn().send("Debes decir de qué personaje quieres recapitular.")
            return

        pnjs = self.__personaje.sala.personajes

        encontrado = 0
        for pnj in pnjs.values():
            if normalizar_id(argumentos[0]) == extraer_id(pnj.nombre):
               argumentos = argumentos[1:]
               encontrado = 1
               break

        if encontrado == 0:
            self.conn().send("No conoces a nadie llamado " + argumentos[0])
            return

        from interfazpnjhablante import InterfazPNJHablante
        if not isinstance(pnj.controlador, InterfazPNJHablante):
            self.conn().send(pnj.nombre + " no responde.")
	    self.conn().send("")
            return
        
        try:
            visita = pnj.controlador._visitas[0]
            items = visita.items()[:]
	    items.reverse()
	    duplicados = []
	    for item in items:
	        if item.tema().agotado_en(visita):
	            disponible = color(31)
	        else:
		    disponible = color(32)
	        duplicados.append(disponible + item.tema().nombre())
		for nombretema in item.relacionados():
		    self.__personaje.tirar_atributo("recapitular", "inteligencia", 0)
		    exitos = self.__personaje.resultado_tirada("recapitular", 20)
		    if exitos > 1:
		        tema = visita._conversacion.contexto(item.relacionados()[nombretema]).tema(nombretema)
		        if tema.agotado_en(visita):
        	            disponible = color(31)
	                else:
		            disponible = color(32)
		        duplicados.append(disponible + tema.nombre())
	    temas = []
	    for tema in duplicados:
	        if tema not in temas: 
	            temas.append(tema)
                    self.conn().send(disponible + tema)
                
        except Exception:
            # Conviene protegerse contra errores en carga de salas. No es bueno que por
            # un fichero de sala mal escrito pete el servidor entero o te eche de la
            # conexión.
	    log.exception( "Ha saltado una excepcion al intentar recapitular")
            if self.conn().is_open:
                self.conn().send("Ha habido un error interno del programa referente a esta conversación.")
                self.conn().send("No puedes recapitular esta conversación. Por favor, habla con algun administrador de Mine.")
        return
    

    def cmd_hablar_pnj(self, comando, argumentos):

	pnjs = [per for per in self.__personaje.sala.personajes.values()
		if not per.es_jugador]
                                  
        if len(pnjs) == 0:
            self.conn().send("No hay PNJs en la sala con quienes hablar")
	    self.conn().send("")
            return
	if len(pnjs) == 1:
	    pnj = pnjs[0]
	else:
	    pnj = None

        if len(argumentos) < 2:
          if len(pnjs) > 1:
            self.conn().send("Debes indicar a qué personaje quieres decir o preguntar algo.")
            self.conn().send("Utiliza el formato +decir <personaje> <tema> o +preguntar <personaje> <tema>")
            return
          elif len(argumentos) < 1:
            self.conn().send("Debes decir o preguntar a alguien por algo.")
            self.conn().send("Utiliza el formato +decir <tema> o +preguntar <tema>")
            return

	if pnj == None:
	    nombre_pnj = argumentos[0]
	    argumentos = argumentos[1:]
	    pnj = self.__personaje.sala.buscar_pnj(nombre_pnj)

	if pnj == None:
            self.conn().send("Aquí no hay ningún PNJ llamado %s." % nombre_pnj)
	    self.conn().send("")
            return

	if comando == 'decir':
	    self.__personaje.decir(pnj, argumentos[0])
	else:
	    self.__personaje.preguntar(pnj, argumentos[0])
        
       #%%if not isinstance(pnj.controlador, InterfazPNJHablante):
       #     self.conn().send(pnj.nombre + " no responde.")
       #     self.conn().send("")
       #     return      
       # 
       # try:
       #     libre = pnj.controlador.conversa_personaje(self.__personaje, comando, 
       #                                        string.join(argumentos, ' '))
       #     if not libre:
       #         self.conn().send("Todavía está hablando con alguien. Debes esperar a que termine.")
       # except Exception:
       #     # Conviene protegerse contra errores en carga de pnjs. No es bueno que por
       #     # un fichero de pnj mal escrito pete el servidor entero o te eche de la
       #     # conexión.
       #     escribir( "Ha saltado una excepcion al intentar " + comando)
       #     escribir_excepcion()
       #     if self.conn().is_open:
       #         self.conn().send("Ha habido un error interno del programa referente a esta conversación.")
       #         self.conn().send("No puedes hacer esta pregunta. Por favor, habla con algun administrador de Mine. Puedes escribir a mine_ste@yahoogroups.com.")


    def cmd_mover(self, id_sala_destino):

        # Comprobar si la puerta está cerrada y si podemos abrirla
        podemos_pasar = 1
        cierre = self.__personaje.sala.salida_cerrada(id_sala_destino)
        id_llave = cierre[0]
        msg_cerrado = cierre[1]
        if id_llave != None:
            podemos_pasar = 0
            for objeto in self.__personaje.mochila:
                if objeto[0].id == id_llave:
                    self.conn().send(color(35) + "Abres el paso con " + objeto[0].nombre + finl)
                    podemos_pasar = 1

        if not podemos_pasar:
            self.conn().send(msg_cerrado)
        else:
            try:
                nueva_sala = Mundo.localizar_sala(id_sala_destino)
            except Exception:
                # Conviene protegerse contra errores en carga de salas. No es bueno que por
                # un fichero de sala mal escrito pete el servidor entero o te eche de la
                # conexión.
		log.exception( "Ha saltado una excepcion al intentar entrar en " + id_sala_destino)
                if self.conn().is_open:
                    self.conn().send("Ha habido un error interno del programa referente a esta sala.")
                    self.conn().send("No puedes ir ahi. Por favor, habla con algun administrador de Mine.")
            else:

                if nueva_sala.volumen_ocupado() + self.__personaje.volumen_total() > nueva_sala.volumen:

                    self.conn().send("Ese lugar está al límite de su capacidad y no cabes. No puedes ir allí.")

                else:

		    # Disparamos el suceso personaje_cruza
		    result = self.__personaje.sala.personaje_cruza(self.__personaje,
		                                                   nueva_sala)

		    if result:

			if self.__personaje.anterior != None:
			    id_lider = self.__personaje.anterior.id
			else:
			    id_lider = None
			
			self.__personaje.mover(nueva_sala)  # aqui se deja de seguir al lider, si lo hay
			self.lanzar_tirada_percep_sala()
			self.cmd_mirar()

			if self.__personaje.salas_visitadas.get(id_sala_destino) != 'si':
			    self.conn().send("Es la primera vez que estás aquí...")
			    self.__personaje.salas_visitadas.update({id_sala_destino:'si'})
			    #Ganamos un punto de experiencia (hay que premiar la exploración)
			    self.__personaje.cambiar_experiencia(+1)

			if id_lider != None:
			    self.conn().send('Ya no estas siguiendo a ' + id_lider)
    

    def cmd_amigos(self, id_amigo):
        self.__personaje.ids_amigos.append(id_amigo)
        self.conn().send("Has añadido a "+id_amigo+" a tu lista de personas de confianza.")


    def cmd_listar_amigos(self):
        self.conn().send("-> Lista de personas de confianza <-")
        self.conn().send('')
        for key in self.__personaje.ids_amigos.keys():
            if self.__personaje.ids_amigos[key] > 0:
                self.conn().send(self.__personaje.color_texto() + '\t'+ key + finl)
    

    def cmd_silencio(self):
        if self.__personaje.silencio == 'no':
            self.__personaje.silencio = 'sí'
        else:
            self.__personaje.silencio = 'no'
        
        self.conn().send("Has elegido que "+self.__personaje.silencio+" haya silencio")
            

    def cmd_susurrar(self, nombre_oyente, mensaje, idioma=Idioma.oestron):
        if len(mensaje) == 0:
            self.conn().send('Tienes que decir algo...')
        elif self.__personaje.id == nombre_oyente:
            self.conn().send('no tiene sentido que te hables a ti mismo')    
        else:
            if self.__personaje.sala != None:
                encontrado = 0
                for personaje in  self.__personaje.sala.personajes.values():
                    if personaje !=self.__personaje and personaje.controlador != None and personaje.id == nombre_oyente:
                        encontrado = 1
                        self.__personaje.susurrar(personaje,mensaje,idioma)
                        self.conn().send("Susurras a "+personaje.id+": "+mensaje)
                if encontrado == 0:
                    self.conn().send('no hay nadie aquí que se llame '+nombre_oyente)
                    

    def cmd_localizar(self, id_personaje):
        try:
            personaje = Mundo.pjs_activos[id_personaje]
            self.conn().send(id_personaje +
                           ' está en ' + personaje.sala.nombre +
                           ' en el area de ' + personaje.sala.area)
        except KeyError:
            self.conn().send('No existe ningun personaje con ese nombre jugando en Minë en este momento')


    def cmd_listar_personajes(self):
        ids_personajes = [ personaje.id for personaje in Mundo.pjs_activos.values() ]

        self.conn().send('En este momento hay ' + `len(ids_personajes)` + ' personajes en Mine:')
	for id in ids_personajes:
	    self.conn().send(id)

            
    def cmd_hablar(self, mensaje, idioma=Idioma.oestron):
        if len(mensaje) > 0:
            self.__personaje.hablar(mensaje,idioma)
            self.conn().send('Dices: '+ self.__personaje.color_texto() + mensaje)
        else:
            self.conn().send('Tienes que decir algo...')
            
    
    def cmd_entorno(self, suceso):
        if len(suceso) > 0:
            self.__personaje.describir_entorno(suceso)
        else:
            self.conn().send('Tienes que describir algo...')
            
        
    def cmd_actuar(self, mensaje):
        if len(mensaje) > 0:
            self.__personaje.actuar(mensaje)
            self.conn().send(self.__personaje.id+' '+mensaje)
        else:
            self.conn().send('Tienes que hacer algo...')
        
            
    def cmd_gritar(self, mensaje, idioma=Idioma.oestron):
        if len(mensaje) > 0:
            self.__personaje.gritar(mensaje,idioma)
            self.conn().send("Gritas: "+mensaje)
        else:
            self.conn().send('Tienes que decir algo...')

        
    def cmd_estadisticas(self):
        self.conn().send(color(31))
        self.conn().send("Estadísticas de " + self.__personaje.nombre)
        self.conn().send("-------------------------------------------------------------------")

        self.conn().send(color(32), 0)
        self.conn().send("Nombre: %-17s Aura: %-17d Nivel: %10d" %
                         (self.__personaje.id,
                          self.__personaje.aura,
                          self.__personaje.nivel))
        self.conn().send("Raza:   %-17s Vida: %-17d Experiencia: %4d" %
                         (self.__personaje.raza.nombre,
                          self.__personaje.vida,
                          self.__personaje.experiencia))
        self.conn().send("Edad:   %-17d Profesion: %-12s Fuerza:       %3d" %
                         (self.__personaje.edad,
                          self.__personaje.profesion.nombre,
                          self.__personaje.atrib["fuerza"]))
        self.conn().send("Sexo:   %-17s Idiomas:                Destreza:     %3d" %
                         (self.__personaje.sexo,
                          self.__personaje.atrib["destreza"]))
        self.conn().send("Altura: %-17.2f   quenya:  %-12s Constitución: %3d" %
                         (self.__personaje.altura,
                          self.__personaje.idiomas[Idioma.quenya],
                          self.__personaje.atrib["constitucion"]))
        self.conn().send("Peso:   %-17d   orco:    %-12s Inteligencia: %3d" %
                         (self.__personaje.peso,
                          self.__personaje.idiomas[Idioma.orco],
                          self.__personaje.atrib["inteligencia"]))
        self.conn().send("Color de ojos: %-11s  enano:   %-12s Sabiduria:    %3d" %
                         (self.__personaje.color_de_ojos,
                          self.__personaje.idiomas[Idioma.enano],
                          self.__personaje.atrib["sabiduria"]))
        self.conn().send("Color de pelo: %-11s  oestron: %-12s Carisma:      %3d" %
                         (self.__personaje.color_de_pelo,
                          self.__personaje.idiomas[Idioma.oestron],
                          self.__personaje.atrib["carisma"]))
	self.conn().send("El idioma en el que hablas es: %s " % (self.__personaje.idioma_base.nombre))
        self.conn().send(self.__personaje.mensaje_hambre)
        self.conn().send(self.__personaje.mensaje_sed)
	self.conn().send("Dinero: %d monedas" % self.__personaje.dinero)
        self.conn().send(color(31) + "-------------------------------------------------------------------" + finl)
        
        
    def cmd_mirar(self, resumen=0):

        sala = self.__personaje.sala
	self.conn().send("")
        self.conn().send(color(31) + "Estás en " + sala.nombre + finl)

	(descripcion, salidas, objetos) = self.__personaje.mirar_sala(sala)

        if not resumen:
            
	    self.conn().send("")
            self.conn().send("------- Descripción del lugar -------")

            for item in descripcion:
                if self.__personaje.resultado_tirada("percepcion_sala", item["dificultad"]) > 0:
		    self.conn().send("")
                    self.conn().send(item["texto"])

	self.conn().send("")
        self.conn().send("--------------------------------------")
	self.conn().send("")
        
	alguna_salida = False
	for salida in salidas:
	    if self.__personaje.resultado_tirada("percepcion_sala", salida["dificultad"]) > 0:
		alguna_salida = True
		direccion = salida["direccion"]
		if direccion in ["arriba", "abajo"]:
		    self.conn().send(color(36) + "Hacia " + direccion + " ves ", 0)
		    self.conn().send(salida["descripcion"], 0)
		    self.conn().send(finl)
		elif direccion == "otro":
		    self.conn().send(color(36) + "También puedes ver ", 0)
		    self.conn().send(salida["descripcion"], 0)
		    self.conn().send(finl)
		else:
		    self.conn().send(color(36) + "Hacia el " + direccion + " ves ", 0)
		    self.conn().send(salida["descripcion"], 0)
		    self.conn().send(finl)   # hay que hacer tres send, porque a veces sale un
					     # error raro si hago solo uno sumando los tres
					     # strings (??)
	if not alguna_salida:
	    self.conn().send(color(36) + "No hay ninguna salida. ¡¡Estás atrapado!!" + finl)

        if len(sala.personajes) > 1:  # siempre habrá al menos uno: nuestro personaje
	    self.conn().send("")
            self.conn().send(color(35) + 'Aquí se encuentran:' + finl)
            for enc in sala.personajes.values():
		if not enc.es_jugador:
                    pass
#                    self.conn().send(color(35) + "Encuentras " + enc.id + finl)
                else:
                    if enc != self.__personaje:
                        self.conn().send(color(35) + enc.nombre + finl)
	    for enc in sala.encuentros:
		self.conn().send(color(35) + enc.get('descripcion') + finl)
	    
	primero = 1
	for objeto in objetos:
	    if len(objeto["instancias"]) > 0:
		if self.__personaje.resultado_tirada("percepcion_sala", objeto["dificultad"]) > 0:
		    if primero:
			self.conn().send("")
			self.conn().send(color(32) + "Aquí hay:" + finl)            
			primero = 0
		    self.conn().send(color(32) + objeto["descripcion"], 0)
		    if len(objeto["instancias"]) > 1:
			self.conn().send(" (" + str(len(objeto["instancias"])) + ")", 0)
		    self.conn().send(finl)

        self.conn().send("")

            
    def cmd_mochila(self):
        self.conn().send(color(31) + "--------- Contenido de la mochila ---------" + finl)
        if len(self.__personaje.mochila) == 0:
            self.conn().send("(la mochila esta vacia)")
        else:
            self.conn().send(color(31) + "%-35s%-8s" % ("Nombre", "Cantidad") + finl)
            for objetos in self.__personaje.mochila:
                self.conn().send("%-35s%8d" % (objetos[0].nombre, len(objetos)))


    def cmd_idioma(self, nombre_idioma_base):
        if len(nombre_idioma_base) == 0:
            self.conn().send("Tu idioma base actual es " + self.__personaje.idioma_base.nombre)
        else:
            idioma_base = Idioma.buscar(nombre_idioma_base)
            if idioma_base != None:
                self.__personaje.idioma_base = idioma_base
                self.conn().send("Tu idioma por defecto es ahora " + idioma_base.nombre)
            else:
                self.conn().send("Lo siento, has de elegir como idioma base uno " +
                                 "de los siguientes: " +
                                 ", ".join([ i.nombre for i in Idioma.lista ]))
        

    def cmd_coger(self, id_objeto, cantidad, n_orden, n_instancia):
        try:

            #%% aqui faltaría lo del sigilo...
            nombre = self.__personaje.coger(id_objeto, cantidad, n_orden, n_instancia)

            self.conn().send("Has cogido " + nombre, 0)
            if cantidad > 1:
                self.conn().send(" (" + str(cantidad) + " unidades)")
            else:
                self.conn().send("")

        except ExcepcionDeJuego, mensaje:

            self.conn().send(str(mensaje))

        
#%%    def cmd_coger(self, id_objeto, cantidad, n_orden, n_instancia):
#%%     encontrados = 0
#%%     n_objeto = -1
#%%
#%%     # Buscar el objeto en la sala. Puede que haya varios con el mismo identificativo,
#%%     # discriminamos con el parametro n_orden.
#%%     for objeto in self.__personaje.sala.objetos:
#%%         n_objeto = n_objeto + 1
#%%         instancias = objeto["instancias"]
#%%         if len(instancias) > 0:
#%%             if normalizar_id(id_objeto) == extraer_id(instancias[0].nombre):
#%%                 encontrados = encontrados + 1
#%%                 if encontrados == n_orden:
#%%
#%%                     # Hemos encontrado el objeto, ahora vemos si hay instancias
#%%                     # suficientes.
#%%                     if (n_instancia + cantidad - 1) > len(instancias):
#%%                         self.conn().send("No hay " + str(n_instancia + cantidad - 1) +
#%%                                          " instancias de ese objeto, solo hay " + 
#%%                                          str(len(instancias)))
#%%                     else:
#%%
#%%                         # Todo ok: cogemos las instancias y las metemos en la mochila
#%%                         for i in range(0, cantidad):
#%%                             instancia = self.__personaje.sala.coger_objeto(n_objeto,
#%%                                                                            n_instancia - 1)
#%%                             self.__personaje.meter_en_mochila(instancia)
#%%
#%%                         self.__personaje.actuar("ha cogido " + instancia.nombre)
#%%                         self.conn().send("Has cogido " + instancia.nombre, 0)
#%%                         if cantidad > 1:
#%%                             self.conn().send(" (" + str(cantidad) + " unidades)")
#%%                         else:
#%%                             self.conn().send("")
#%%
#%%                     break
#%%                 
#%%     if encontrados == 0:
#%%         self.conn().send("No hay en la sala ningún objeto con identificativo " + id_objeto)
#%%     elif encontrados < n_orden:
#%%         self.conn().send("No hay en la sala suficientes objetos con identificativo " +
#%%                          id_objeto + ", solo hay " + str(encontrados))


#%%    def cmd_coger(self, nombre_objeto, cantidad=1):
#%%
#%%        adquiridos = 0 #número de fallos
#%%        despues = 0
#%%        antes = 0
#%%        
#%%        for objeto_en_equipo in self.__personaje.equipo:
#%%            if objeto_en_equipo["id"] == nombre_objeto:
#%%                antes = len(objeto_en_equipo["instancias"])
#%%                
#%%        for i in range(cantidad):
#%%            self.__personaje.sala.coger_objeto(self.__personaje, nombre_objeto)
#%%
#%%        for objeto_en_equipo in self.__personaje.equipo:
#%%            if objeto_en_equipo["id"] == nombre_objeto:
#%%                despues = len(objeto_en_equipo["instancias"])
#%%                
#%%        if despues - antes <1:
#%%            self.conn().send("No hay en la sala un objeto con identificativo "+nombre_objeto)
#%%        else:
#%%            self.conn().send("Se cogieron "+str(despues-antes) +" "+nombre_objeto+" de "+str(cantidad)+" indicados")


    def cmd_dejar(self, id_objeto, cantidad, n_orden, n_instancia):
        try:

            #%% aqui faltaría lo del sigilo...
            nombre = self.__personaje.dejar(id_objeto, cantidad, n_orden, n_instancia)

            self.conn().send("Has dejado " + nombre, 0)
            if cantidad > 1:
                self.conn().send(" (" + str(cantidad) + " unidades)")
            else:
                self.conn().send("")

        except ExcepcionDeJuego, mensaje:

            self.conn().send(str(mensaje))


        
#%%    def cmd_dejar(self, id_objeto, cantidad, n_orden, n_instancia, dificultad = 0):
#%%     encontrados = 0
#%%     n_objeto = -1
#%%
#%%     # Buscar el objeto en la mochila. Puede que haya varios con el mismo identificativo,
#%%     # discriminamos con el parametro n_orden.
#%%     for instancias in self.__personaje.mochila:
#%%         n_objeto = n_objeto + 1
#%%         if normalizar_id(id_objeto) == extraer_id(instancias[0].nombre):
#%%             encontrados = encontrados + 1
#%%             if encontrados == n_orden:
#%%
#%%                 # Hemos encontrado el objeto, ahora vemos si hay instancias
#%%                 # suficientes.
#%%                 if (n_instancia + cantidad - 1) > len(instancias):
#%%                     self.conn().send("No tienes " + str(n_instancia + cantidad - 1) +
#%%                                      " unidades de ese objeto en la mochila, solo tienes " + 
#%%                                      str(len(instancias)))
#%%                 else:
#%%
#%%                     # Todo ok: sacamos las instancias de la mochila y las dejamos
#%%                     # en la sala
#%%                     for i in range(0, cantidad):
#%%                         instancia = self.__personaje.sacar_de_mochila(n_objeto,
#%%                                                                       n_instancia - 1)
#%%                         self.__personaje.sala.dejar_objeto(instancia, dificultad)             
#%%
#%%                     if dificultad == 0:
#%%                         self.__personaje.actuar("ha dejado " + instancia.nombre)
#%%                         self.conn().send("Has dejado " + instancia.nombre, 0)
#%%                     else:
#%%                         self.__personaje.actuar("ha escondido algo")
#%%                         self.conn().send("Has escondido " + instancia.nombre, 0)
#%%
#%%                     if cantidad > 1:
#%%                         self.conn().send(" (" + str(cantidad) + " unidades)")
#%%                     else:
#%%                         self.conn().send("")
#%%
#%%                 break
#%%                 
#%%     if encontrados == 0:
#%%         self.conn().send("No tienes en la mochila ningún objeto con identificativo " +
#%%                          id_objeto)
#%%     elif encontrados < n_orden:
#%%         self.conn().send("No tienes en la mochila suficientes objetos con identificativo " +
#%%                          id_objeto + ", solo tienes " + str(encontrados))


    def cmd_esconder(self, id_objeto, cantidad, n_orden, n_instancia):
        try:

            #%% aqui faltaría lo del sigilo...
            nombre = self.__personaje.esconder(id_objeto, cantidad, n_orden, n_instancia)

            self.conn().send("Has escondido " + nombre, 0)
            if cantidad > 1:
                self.conn().send(" (" + str(cantidad) + " unidades)")
            else:
                self.conn().send("")

        except ExcepcionDeJuego, mensaje:

            self.conn().send(str(mensaje))


    def cmd_dar(self, id_receptor, id_objeto, cantidad, n_orden, n_instancia):
        encontrados = 0
        n_objeto = -1

        # Buscar el id_receptor en la sala actual.
        if self.__personaje.sala != None:
            receptor_encontrado = 0
            for personaje in  self.__personaje.sala.personajes.values():
                if personaje != self.__personaje and personaje.controlador != None and string.lower(personaje.id) == string.lower(id_receptor):
                    receptor_encontrado = 1
                    receptor = personaje
                    break
            if receptor_encontrado == 0:
                self.conn().send('No hay nadie aquí que se llame '+id_receptor)
                return
            
        # Buscar el objeto en la mochila. Puede que haya varios con el mismo identificativo,
        # discriminamos con el parametro n_orden.
        for instancias in self.__personaje.mochila:
            n_objeto = n_objeto + 1
            if normalizar_id(id_objeto) == extraer_id(instancias[0].nombre):
                encontrados = encontrados + 1
                if encontrados == n_orden:

                    # Hemos encontrado el objeto, ahora vemos si hay instancias
                    # suficientes.
                    if (n_instancia + cantidad - 1) > len(instancias):
                        self.conn().send("No tienes " + str(n_instancia + cantidad - 1) +
                                         " unidades de ese objeto en la mochila, solo tienes " + 
                                         str(len(instancias)))
                    else:
                        #Comprobar antes de seguir que el personaje que da el objeto se encuentra
                        #en la lista de confianza del receptor (salvo que el que da sea un Maia...)

                        if not self.__personaje.es_maia:
                            try:
                                confianza = receptor.ids_amigos[self.__personaje.id]
                                if confianza < 1:
                                    raise KeyError
                            except KeyError, e:
                                self.conn().send(receptor.nombre + " no acepta tu objeto.")
                                self.__personaje.actuar_individual(receptor, "te ha intentado dar " + id_objeto + " pero te has negado.")
                                break
                        
                        # Todo ok: sacamos las instancias de la mochila
                        for i in range(0, cantidad):
                            instancia = self.__personaje.sacar_de_mochila(n_objeto,
                                                                          n_instancia - 1)
                            receptor.meter_en_mochila(instancia)

                        #mensajes
                        self.__personaje.actuar("ha dado " + instancia.nombre + " a " + receptor.nombre)
                        self.conn().send("Has dado " + instancia.nombre + " a " + receptor.nombre, 0)
                        self.__personaje.actuar_individual(receptor, "te ha dado " + instancia.nombre +' ('+str(cantidad)+' unidad[es])')
                        if cantidad > 1:
                            self.conn().send(" (" + str(cantidad) + " unidades)")
                        else:
                            self.conn().send("")

                    break
                    
        if encontrados == 0:
            self.conn().send("No tienes en la mochila ningún objeto con identificativo " +
                             id_objeto)
        elif encontrados < n_orden:
            self.conn().send("No tienes en la mochila suficientes objetos con identificativo " +
                             id_objeto + ", solo tienes " + str(encontrados))


#%%    def cmd_dejar(self, nombre_objeto, cantidad, accion = "dejado",dif=0):
#%%        fallos = 0
#%%        for i in range(cantidad):
#%%            encontrar_id = self.__personaje.sala.dejar_objeto(self.__personaje, nombre_objeto, dif)
#%%            if encontrar_id[0] == 0:
#%%                fallos +=1
#%%        if fallos != cantidad:
#%%            self.conn().send("Has "+accion+" en la sala "+str(cantidad - fallos)+" "+encontrar_id[1])
#%%            if fallos !=0:
#%%                self.conn().send("No fue posible dejar "+str(cantidad)+ " "+ encontrar_id[1])
#%%            self.cmd_actuar("deja algo.")
#%%        else:
#%%            self.conn().send("No hay en tu inventario un objeto con identificativo "+encontrar_id[1])


    def cmd_comer(self, id_objeto, n_orden, n_instancia):
        self.__personaje.comer(id_objeto, n_orden, n_instancia)


    def cmd_beber(self, id_objeto, n_orden, n_instancia):
        self.__personaje.beber(id_objeto, n_orden, n_instancia)

        
    def cmd_usar(self, id_objeto, n_orden, n_instancia):
        self.__personaje.usar(id_objeto, n_orden, n_instancia)

        
    def cmd_usar_con(self, id_objeto, n_orden, n_instancia, id_objeto2, n_orden2, n_instancia2):
        self.__personaje.usar_con(id_objeto, n_orden, n_instancia,
                                  id_objeto2, n_orden2, n_instancia2)

#%%     encontrados = 0
#%%     n_objeto = -1
#%%
#%%     # Buscar el objeto en la mochila. Puede que haya varios con el mismo identificativo,
#%%     # discriminamos con el parametro n_orden.
#%%     for instancias in self.__personaje.mochila:
#%%         n_objeto = n_objeto + 1
#%%         if normalizar_id(id_objeto) == extraer_id(instancias[0].nombre):
#%%             encontrados = encontrados + 1
#%%             if encontrados == n_orden:
#%%
#%%                 # Hemos encontrado el objeto, ahora vemos si hay instancias
#%%                 # suficientes.
#%%                 if (n_instancia) > len(instancias):
#%%                     self.conn().send("No tienes " + str(n_instancia) +
#%%                                      " instancias de ese objeto en la mochila, solo tienes " + 
#%%                                      str(len(instancias)))
#%%                 else:
#%%
#%%                     # Todo ok: usamos la instancia
#%%                     instancia = instancias[n_instancia - 1]
#%%
#%%                     if not instancia.puede_usar(self.__personaje):
#%%                         self.conn().send("No puedes usar este objeto.")
#%%                     else:
#%%                         instancia.usar(self.__personaje)
#%%                                      
#%%        #self.conn().send("Aún no se pueden usar objetos...")
#%%        #if nombre_objeto == "":
#%%        #    self.conn.send("Debes especificar un objeto")
#%%        #else:
#%%        #    resultado =  encontrar_en_equipo(nombre_objeto, self.personaje.equipo)
#%%        #if resultado[1] == 0:
#%%        #    self.conn().send('No tienes un objeto llamado '+nombre_objeto)
#%%        #else:
#%%        #    for efecto in resultado[0][:]:
#%%        #        pass


    def cmd_poner(self, posicion, id_objeto, n_orden, n_instancia):
        self.__personaje.ponerse(posicion, id_objeto, n_orden, n_instancia)


    def cmd_quitar(self, posicion):
        self.__personaje.quitarse(posicion)


    def cmd_examinar(self, id_objeto, n_orden, n_instancia):
        encontrados = 0
        n_objeto = -1

	# Buscar el objeto en la mochila. Puede que haya varios con el mismo identificativo,
	# discriminamos con el parametro n_orden.
	for instancias in self.__personaje.mochila:
	    n_objeto = n_objeto + 1
	    if normalizar_id(id_objeto) == extraer_id(instancias[0].nombre):
		encontrados = encontrados + 1
		if encontrados == n_orden:

		    # Hemos encontrado el objeto, ahora vemos si hay instancias
		    # suficientes.
		    if (n_instancia) > len(instancias):
			self.conn().send("No tienes " + str(n_instancia) +
					 " instancias de ese objeto en la mochila, solo tienes " + 
					 str(len(instancias)))
		    else:

			# Todo ok: examinamos la instancia
			instancia = instancias[n_instancia - 1]
			descripcion = self.__personaje.mirar_objeto(instancia)
			for item in descripcion:
			    if self.__personaje.prueba("inteligencia", 0, item["dificultad"], 0) >= 0:
				self.conn().send(item["texto"])

			self.conn().send("Valor (me): " + str(instancia.valor) + "," \
			                 " Peso (kg): " + str(instancia.peso) + "," \
			                 " Volumen: " + str(instancia.volumen) + "," \
			                 " Estado (1-100): " + str(instancia.estado))
	else:
	    self.conn().send("No tienes ningún objeto llamado %s" % id_objeto)


#%%			self.conn().send("Usos posibles:")
#%%			for uso in instancia.usos:
#%%			    self.conn().send('Tipo: '+uso['tipo']+'\t Posición: '+uso['posicion'])


#%%    def cmd_examinar(self, nombre_objeto,posicion):
#%%
#%%        encontrado = 0
#%%
#%%        self.conn().send("Examinas "+nombre_objeto+" "+"("+str(posicion)+")")
#%%        
#%%        for objeto in self.__personaje.equipo[:]:
#%%            if objeto["id"] == nombre_objeto:
#%%                if posicion > len(objeto["instancias"]):
#%%                    self.conn().send("No tienes tanto de eso.")
#%%                    objeto_examinado = 0
#%%                else:
#%%                    objeto_examinado = objeto["instancias"][posicion-1]
#%%                encontrado = 1
#%%                break
#%%        if encontrado == 0:
#%%            self.conn().send('No tienes un objeto llamado '+nombre_objeto)
#%%        else:
#%%            if objeto_examinado == 0: pass
#%%            else:
#%%                for item in objeto_examinado.items:
#%%                    if self.__personaje.atrib["inteligencia"] >= item["dificultad"]:
#%%                        self.conn().send(item["texto"])
#%%                    else:
#%%                        pass
#%%                self.conn().send("Valor (me): "+str(objeto_examinado.valor)+","\
#%%                " Peso (kg): "+str(objeto_examinado.peso)+","\
#%%                " Volumen: "+str(objeto_examinado.volumen)+","\
#%%                " Estado (1-100): "+str(objeto_examinado.estado))
#%%                self.conn().send("Usos posibles:")
#%%                for uso in objeto_examinado.usos:
#%%                    self.conn().send('Tipo: '+uso['tipo']+'\t Posición: '+uso['posicion'])


    def cmd_observar(self, nombre_oponente):

	oponente = self.__personaje.sala.buscar_personaje(nombre_oponente)

	if oponente == None:
            self.conn().send("Aquí no hay nadie llamado " + nombre_oponente)
            return

        result = self.__personaje.comparacion(oponente)

	if result == Personaje.COMP_INF_MAS_FUERTE:
	    adjetivo = "infinitamente más fuerte"
	elif result == Personaje.COMP_MUCHO_MAS_FUERTE:
	    adjetivo = "mucho más fuerte"
	elif result == Personaje.COMP_BAST_MAS_FUERTE:
	    adjetivo = "bastante más fuerte"
	elif result == Personaje.COMP_ALGO_MAS_FUERTE:
	    adjetivo = "algo más fuerte"
	elif result == Personaje.COMP_POR_EL_ESTILO:
	    adjetivo = "por el estilo"
	elif result == Personaje.COMP_ALGO_MAS_DEBIL:
	    adjetivo = "algo más débil"
	elif result == Personaje.COMP_BAST_MAS_DEBIL:
	    adjetivo = "bastante más débil"
	elif result == Personaje.COMP_MUCHO_MAS_DEBIL:
	    adjetivo = "mucho más débil"
	elif result == Personaje.COMP_INF_MAS_DEBIL:
	    adjetivo = "infinitamente más débil"
	
	self.conn().send(oponente.nombre + " es " + adjetivo + " que tú")
	
	if oponente == self.__personaje:
	    self.conn().send('Tu descripción:')
	    for key in self.__personaje.descripcion:
		self.conn().send(color(31)+key["texto"]+finl)
	else:
	    self.conn().send('Descripción:')
	    descripcion = self.__personaje.mirar_personaje(oponente)
	    for key in descripcion:
		if self.__personaje.atrib["inteligencia"] + tirar_dados(3) > key["dificultad"]:
		    self.conn().send(color(31)+key["texto"]+finl)
        

    def cmd_seguir(self, nombre_lider):
	lider = self.__personaje.sala.buscar_personaje(nombre_lider)
	if lider == None:
            self.conn().send('Aquí no hay nadie llamado ' + nombre_lider)
	if lider == self.__personaje:
	    self.conn().send('¡No puedes seguirte a tí mismo/a!')
        else:
            if self.__personaje.anterior != None:
                self.__personaje.no_seguir()
            self.__personaje.seguir(lider)
                        

    def cmd_no_seguir(self):
        if self.__personaje.anterior == None:
            self.conn().send('¡No estabas siguiendo a nadie!')
        else:
            self.__personaje.no_seguir()


    def cmd_ip(self):
        self.conn().send('Estás conectado desde la dirección ' + self.conn().ip)


    def cmd_area(self):
        self.conn().send('Estás en el área ' + self.__personaje.sala.area)

                        
    def cmd_atacar(self, nombre_oponente):
	oponente = self.__personaje.sala.buscar_personaje(nombre_oponente)
	if oponente == None:
            self.conn().send("Aquí no hay nadie llamado " + nombre_oponente)
            self.estado_0()
        else:
            self.oponente = oponentes[0]
            
            if self.oponente.estado == "muerto":
                self.conn().send("¡" + nombre_oponente + " ya está muerto/a!")
                self.estado_0()
            else:
                self.__personaje.tirar_competicion("evaluar_oponente", self.oponente, "carisma", "sabiduria")
		if self.__personaje.resultado_competicion("evaluar_oponente"):
                    self.cmd_observar(nombre_oponente)
                    self.estado_combate_0()
                else:
                    self.cbt_empieza_combate_atacas()
                    self.cbt_pegar()
                    if self.oponente.estado == "muerto":
                        self.cbt_oponente_muerto()
                        self.cbt_termina_combate()
                        self.estado_0()
                    elif self.__personaje.estado == "muerto":
                        self.cbt_personaje_muerto()
                        self.cbt_termina_combate()
                        self.estado_0()
                    else:
                        self.estado_combate_1()


    def cmd_reloj(self):
        ahora = FechaHoraMine.ahora()
        self.conn().send("%s (%s)" % (str(ahora), ahora.desc_seccion()))

            
    def cmd_pagar(self, nombre_otro_personaje, monedas):
        if self.__personaje.id == nombre_otro_personaje:
            self.conn().send('no tiene sentido que te pagues a ti mismo')
        else:
            if self.__personaje.sala != None:
                encontrado = 0
                for personaje in self.__personaje.sala.personajes.values():
		    if personaje != self.__personaje \
		       and personaje.controlador != None \
		       and personaje.id == nombre_otro_personaje:
                        encontrado = 1
			self.__personaje.pagar(personaje, monedas)
			self.conn().send('Has pagado %d monedas a %s' % (monedas, personaje.id))
                if encontrado == 0:
                    self.conn().send('no hay nadie aquí que se llame ' + nombre_otro_personaje)


    def cmd_comprar(self, id_objeto, cantidad, n_orden, n_instancia):
	self.__personaje.comprar(id_objeto, n_orden, n_instancia, cantidad)

            
# Código para pruebas unitarias del módulo.

if (__name__ == '__main__'):
    print "No hay código para pruebas unitarias del módulo."
    print "Para probar, ejecutar mine.py y conectarse via telnet."

