/[ambar]/ambar/sala.py
ViewVC logotype

Diff of /ambar/sala.py

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 2.8 by amoyav, Sat May 31 21:24:44 2003 UTC revision 2.9 by g2pudeto, Tue Jun 3 17:39:57 2003 UTC
# Line 60  class Sala(object): Line 60  class Sala(object):
60      EXT_DESC_SALAS = '.xml'      EXT_DESC_SALAS = '.xml'
61      DIR_SALAS = 'salas'      DIR_SALAS = 'salas'
62      EXT_SALAS = ''      EXT_SALAS = ''
63    
64    
65        TIPOS_SALA = { "Población" : [  "calle",    "callejón",     "plaza",
66                                        "portal",   "pasadizo",     "arco",
67                                        "puerto",   "embarcadero",  "azotea" ],
68    
69                    "Edificio" : [ "salón","habitación","pasillo",
70                                    "escaleras","vestíbulo","cuarto sin ventanas",
71                                    "sótano", "calabozo", "alcantarilla", "tejado",
72                                    "balcón", "letrina" ],
73                    
74                    "Campo" : [ "llanura", "bosque", "claro de bosque", "colina",
75                                "valle", "pantano", "páramo", "desierto" ],
76                                
77                    "Agua" : [ "ribera", "costa", "acantilado", "cala", "rio",
78                                "lago", "mar", "islote" ],
79                    
80                    "Montaña" : [ "cima", "ladera", "promontorio", "grieta",
81                                    "desfiladero", "quebrada", "abismo", "cornisa" ],
82                    
83                    "Caverna" : ["entrada", "cueva", "pasadizo", "sima",
84                                    "rio subterráneo", "lago subterráneo"]
85                   }
86                    
87      # Métodos estáticos      # Métodos estáticos
88    
# Line 89  class Sala(object): Line 112  class Sala(object):
112      # Atributos públicos de la clase      # Atributos públicos de la clase
113    
114      def __leer_id(self): return self.__id      def __leer_id(self): return self.__id
115        
116      id = property(__leer_id,      def __set_id(self,id): self.__id = id
117        id = property(__leer_id,__set_id,
118                    doc="""(string): identifica univocamente a la sala.                    doc="""(string): identifica univocamente a la sala.
119    
120                        No puede contener espacios y debe tener el formato:                        No puede contener espacios y debe tener el formato:
# Line 101  class Sala(object): Line 125  class Sala(object):
125                        """)                        """)
126    
127      def __leer_version(self): return self.__version      def __leer_version(self): return self.__version
128        
129      version = property(__leer_version,      def __set_version(self,version): self.__version = version
130        
131        version = property(__leer_version, __set_version,
132                         doc="""(string): versión del sistema de salas.                         doc="""(string): versión del sistema de salas.
133    
134                             Invariantes:                             Invariantes:
# Line 111  class Sala(object): Line 137  class Sala(object):
137    
138      def __leer_autor(self): return self.__autor      def __leer_autor(self): return self.__autor
139    
140      autor = property(__leer_autor,      def __set_autor(self,autor): self.__autor = autor
141            
142        autor = property(__leer_autor, __set_autor,
143                       doc="""(string): nombre del autor de la descripción.                       doc="""(string): nombre del autor de la descripción.
144    
145                           Invariantes:                           Invariantes:
# Line 120  class Sala(object): Line 148  class Sala(object):
148    
149      def __leer_area(self): return self.__area      def __leer_area(self): return self.__area
150    
151      area = property(__leer_area,      def __set_area(self, area): self.__area =area
152        
153        area = property(__leer_area, __set_area,
154                      doc="""(string): nombre del area a la que pertenece la sala.                      doc="""(string): nombre del area a la que pertenece la sala.
155                                                
156                          Invariantes:                          Invariantes:
# Line 128  class Sala(object): Line 158  class Sala(object):
158                          """)                          """)
159    
160      def __leer_comentario(self): return self.__comentario      def __leer_comentario(self): return self.__comentario
161        
162      comentario = property(__leer_comentario,      def __set_comentario(self, comentario): self.__comentario = comentario
163        
164        comentario = property(__leer_comentario, __set_comentario,
165                            doc="""(string): comentario explicativo del fichero de sala.                            doc="""(string): comentario explicativo del fichero de sala.
166    
167                                Invariantes:                                Invariantes:
# Line 137  class Sala(object): Line 169  class Sala(object):
169                                """)                                """)
170    
171      def __leer_nombre(self): return self.__nombre      def __leer_nombre(self): return self.__nombre
172        
173      nombre = property(__leer_nombre,      def __set_nombre(self,nombre): self.__nombre = nombre
174        
175        nombre = property(__leer_nombre,__set_nombre,
176                        doc="""(string): texto con el nombre corto de la sala,                        doc="""(string): texto con el nombre corto de la sala,
177                            tal como sale en pantalla.                            tal como sale en pantalla.
178    
# Line 148  class Sala(object): Line 182  class Sala(object):
182    
183      def __leer_aura(self): return self.__aura      def __leer_aura(self): return self.__aura
184    
185      aura = property(__leer_aura,      def __set_aura(self, aura): self.__aura = aura
186        
187        aura = property(__leer_aura, __set_aura,
188                      doc="""(int): nivel de aura de la sala (0-50 = malvado,                      doc="""(int): nivel de aura de la sala (0-50 = malvado,
189                          50 = normal, 50-100 = bueno).                          50 = normal, 50-100 = bueno).
190    
# Line 157  class Sala(object): Line 193  class Sala(object):
193                          """)                          """)
194    
195      def __leer_tipo(self): return self.__tipo      def __leer_tipo(self): return self.__tipo
196        
197      tipo = property(__leer_tipo,      def __set_tipo(self, tipo): self.__tipo = tipo
198        
199        tipo = property(__leer_tipo,__set_tipo,
200                      doc="""(string): el tipo de sala.                      doc="""(string): el tipo de sala.
201                          """)                          """)
202    
203      def __leer_subtipo(self): return self.__subtipo      def __leer_subtipo(self): return self.__subtipo
204      
205        def __set_subtipo(self, subtipo): self.__subtipo = subtipo
206    
207      subtipo = property(__leer_subtipo,      subtipo = property(__leer_subtipo,__set_subtipo,
208                         doc="""(string): el subtipo de sala.                         doc="""(string): el subtipo de sala.
209                             """)                             """)
210    
211      def __leer_volumen(self): return self.__volumen      def __leer_volumen(self): return self.__volumen
212        
213        def __set_volumen(self, volumen):
214            self.__volumen = float(volumen)
215            print("volumen: "+`self.volumen`)
216    
217      volumen = property(__leer_volumen,      volumen = property(__leer_volumen,__set_volumen,
218                         doc="""(float): volumen total que puede contener                         doc="""(float): volumen total que puede contener
219                             (1 unidad = tamaño de un humano).                             (1 unidad = tamaño de un humano).
220                                                        
# Line 180  class Sala(object): Line 224  class Sala(object):
224    
225      def __leer_luz(self): return self.__luz      def __leer_luz(self): return self.__luz
226    
227      luz = property(__leer_luz,      def __set_luz(self, luz): self.__luz = luz
228    
229        luz = property(__leer_luz, __set_luz,
230                     doc="""(int): nivel de iluminación (0 = oscuridad total,                     doc="""(int): nivel de iluminación (0 = oscuridad total,
231                         100 = enfrente de Eru).                         100 = enfrente de Eru).
232    
# Line 190  class Sala(object): Line 236  class Sala(object):
236    
237      def __leer_combate(self): return self.__combate      def __leer_combate(self): return self.__combate
238    
239      combate = property(__leer_combate,      def __set_combate(self, combate): self.__combate = combate
240    
241        combate = property(__leer_combate, __set_combate,
242                         doc="""(string): si se puede combatir en esta sala ("si" o "no").                         doc="""(string): si se puede combatir en esta sala ("si" o "no").
243    
244                             Invariantes:                             Invariantes:
# Line 199  class Sala(object): Line 247  class Sala(object):
247    
248      def __leer_ocultabilidad(self): return self.__ocultabilidad      def __leer_ocultabilidad(self): return self.__ocultabilidad
249    
250      ocultabilidad = property(__leer_ocultabilidad,      def __set_ocultabilidad(self, ocultabilidad): self.__ocultabilidad = ocultabilidad
251    
252        ocultabilidad = property(__leer_ocultabilidad,__set_ocultabilidad,
253                               doc="""(int): facilidad de ocultarse (0 = imposible, 100 = seguro).                               doc="""(int): facilidad de ocultarse (0 = imposible, 100 = seguro).
254    
255                                   Invariantes:                                   Invariantes:
# Line 333  class Sala(object): Line 383  class Sala(object):
383                                     n_jugadores <= len(personajes)                                     n_jugadores <= len(personajes)
384                                 """)                                 """)
385    
386        def __leer_elem_sal(self): return self.__elem_sal
387        
388        elem_sal=property(__leer_elem_sal, doc=""" """)
389        
390      # Constructor      # Constructor
391        #def __init__(self, conservar_arbol_xml = 0):
392      def __init__(self, id):      #tenemos que hacer un constructor que parta de cero        
393                
394        def __init__(self, id, conservar_arbol_xml = 0):
395          """Crea una sala nueva a partir de un fichero de descripción de sala.          """Crea una sala nueva a partir de un fichero de descripción de sala.
396                    
397          Requiere:          Requiere:
# Line 351  class Sala(object): Line 407  class Sala(object):
407          #                     __fecha_fichero >= 0          #                     __fecha_fichero >= 0
408    
409          self.__id = id          self.__id = id
410          self.__inicializar_sala()          self.__inicializar_sala(conservar_arbol_xml)
411    
412    
413      def __inicializar_sala(self):      def __inicializar_sala(self,conservar_arbol_xml):
414          """Rellena todos los datos de la sala a partir de su fichero          """Rellena todos los datos de la sala a partir de su fichero
415          de descripcion.          de descripcion.
416          """          """
417          self.__personajes = {}          self.__personajes = {}
418          self.__n_jugadores = 0            self.__n_jugadores = 0  
419    
420    
421            # Atributos privados:
422            #
423            # __arbol_xml (minidom.Document, opcional): arbol XML leido del fichero de descripcion.
424    
425          archivo = os.path.join(Sala.DIR_DESC_SALAS, self.__id.split('-')[0],          archivo = os.path.join(Sala.DIR_DESC_SALAS, self.__id.split('-')[0],
426                                 self.__id + Sala.EXT_DESC_SALAS)                                 self.__id + Sala.EXT_DESC_SALAS)
         stream = open(archivo)  
         doc_xml = minidom.parse(stream).documentElement  
         stream.close()  
427    
428          self.__fecha_fichero = os.path.getmtime(archivo)          self.__fecha_fichero = os.path.getmtime(archivo)
429            
430            arbol_xml = minidom.parse(archivo)
431            
432            elem_sala=arbol_xml.documentElement
433            self.__parsear_sala(elem_sala)
434    
435          self.__iniciar_parseador(doc_xml)          elem_id = elem_sala.getElementsByTagName('id')[0]
436            self.__parsear_id(elem_id)
437    
438          self.__parsear_sala(doc_xml)          elem_nombre = elem_sala.getElementsByTagName('nombre')[0]
439          self.__parsear_id(doc_xml)                self.__parsear_nombre(elem_nombre)
         self.__parsear_nombre(doc_xml)    
         self.__parsear_descripcion(doc_xml)  
         self.__parsear_salidas(doc_xml)  
         self.__parsear_propiedades(doc_xml)  
         self.__parsear_objetos(doc_xml)  
         self.__parsear_encuentros(doc_xml)  
440    
441            elem_propiedades = elem_sala.getElementsByTagName('propiedades')[0]
442            self.__parsear_propiedades(elem_propiedades)
443            
444            elem_descripcion = elem_sala.getElementsByTagName('descripcion')[0]
445            self.__parsear_descripcion(elem_descripcion)
446                    
447            elem_salidas = elem_sala.getElementsByTagName('salidas')[0]
448            self.__parsear_salidas(elem_salidas)
449                    
450      def __iniciar_parseador(self, doc_xml):          elem_objetos = elem_sala.getElementsByTagName('objetos')[0]
451          """Esta función borra todos los nodos de tipo Text de un          self.__parsear_objetos(elem_objetos)
         elemento DOM"""  
452                    
453          for nodo in doc_xml.childNodes[:]:          elem_encuentros = elem_sala.getElementsByTagName('encuentros')[0]
454              if not 'Element:' in str(nodo).split():          self.__parsear_encuentros(elem_encuentros)
                 doc_xml.childNodes.remove(nodo)  
455    
456                    if conservar_arbol_xml:
457      def __parsear_sala(self, doc_xml):              self.__elem_sala=elem_sala
458                self.__elem_id=elem_id
459                self.__elem_nombre=elem_nombre
460                self.__elem_propiedades=elem_propiedades
461                self.__elem_descripcion=elem_descripcion
462                self.__elem_salidas=elem_salidas
463                self.__elem_objetos=elem_objetos
464                self.__elem_encuentros=elem_encuentros
465                self.__arbol_xml = arbol_xml
466                    
467                  
468        def __parsear_sala(self, elem_sala):
469          """Extrae la información del elemento sala:          """Extrae la información del elemento sala:
470              area: el área a la que pertenece la sala              area: el área a la que pertenece la sala
471              autor: el autor de la sala              autor: el autor de la sala
472              version: la versión del tipo de sala"""              version: la versión del tipo de sala
473          version_desc_sala = doc_xml.attributes["version"].value.encode('ISO-8859-1')              comentario: el comentario de la sala """
474            
475            version_desc_sala = extraer_atributo_xml(elem_sala,'version')
476          if version_desc_sala != Sala.VERSION_DESC_SALA:          if version_desc_sala != Sala.VERSION_DESC_SALA:
477              raise ValueError("Version incorrecta del fichero descriptor de sala " + self.__id + ": " +              raise ValueError("Version incorrecta del fichero descriptor de sala " + self.__id + ": " +
478                               version_desc_sala + " cuando se esperaba " + Sala.VERSION_DESC_SALA)                  version_desc_sala + " cuando se esperaba " + Sala.VERSION_DESC_SALA)
479    
480          self.__version = Sala.VERSION_SALA          self.__version = Sala.VERSION_SALA
481                    
482          self.__autor = doc_xml.attributes["autor"].value.encode('ISO-8859-1')          self.__autor = extraer_atributo_xml(elem_sala,'autor')
483          self.__area = doc_xml.attributes["area"].value.encode('ISO-8859-1')          self.__area = extraer_atributo_xml(elem_sala,'area')
484          try:          
485              self.__comentario = doc_xml.attributes["comentario"].value.encode('ISO-8859-1')          if elem_sala.hasAttribute('comentario'):
486          except:              self.__comentario = extraer_atributo_xml(elem_sala,'comentario')
487              self.__comentario = ""          else:
488                self.__comentario = ""
489                    
490        def __parsear_id(self, elem_id):
     def __parsear_id(self, doc_xml):  
491          """Extrae el id de la sala"""          """Extrae el id de la sala"""
492          id_fichero = doc_xml.childNodes[0].childNodes[0].data.encode('ISO-8859-1')          id_fichero = extraer_contenido_xml(elem_id)
493          if id_fichero != self.__id:          if id_fichero != self.__id:
494              raise ValueError("El id no coincide con el nombre del fichero")              raise ValueError("El id no coincide con el nombre del fichero")
           
495    
496      def __parsear_nombre(self, doc_xml):      def __parsear_nombre(self, elem_nombre):
497          """Extrae el nombre de la sala"""          """Extrae el nombre de la sala"""
498          self.__nombre = doc_xml.childNodes[1].childNodes[0].data.encode('ISO-8859-1')          self.__nombre = extraer_contenido_xml(elem_nombre)
499    
500        def __parsear_propiedades(self, elem_propiedades):  
     def __parsear_propiedades(self, doc_xml):    
501          """Extrae las propiedades globales de la sala."""          """Extrae las propiedades globales de la sala."""
502            if elem_propiedades.hasAttribute('aura'):
503                try:
504                    self.__aura = int(extraer_atributo_xml(elem_propiedades,'aura'))
505                except ValueError:
506                    raise ValueError("Error en sala " + self.__id +
507                                         ". La propiedad de aura tiene que ser un número.")
508                if not self.__aura in range(0, 101):
509                    raise ValueError("Error en sala " + self.__id +
510                                         ". La propiedad de aura tiene que ser de 0 a 100.")
511            else:
512                self.__aura = 50
513            
514          try:          try:
515              self.__aura = int(doc_xml.childNodes[4].attributes["aura"].value)              self.__tipo = extraer_atributo_xml(elem_propiedades,'tipo')
         except:  
             self.__aura = 50  
         try:  
             self.__tipo = doc_xml.childNodes[4].attributes["tipo"].value  
516          except:          except:
517              self.__tipo = 'sin_tipo'              self.__tipo = 'sin_tipo'
518          self.__volumen = float(doc_xml.childNodes[4].attributes["volumen"].value)          
519          self.__luz = int(doc_xml.childNodes[4].attributes["luz"].value)          self.__volumen = float(extraer_atributo_xml(elem_propiedades,'volumen'))
520            self.__luz = int(extraer_atributo_xml(elem_propiedades,'luz'))
521          try:          try:
522              self.__combate = doc_xml.childNodes[4].attributes["combate"].value              self.__combate = extraer_atributo_xml(elem_propiedades,'combate')
523          except:          except:
524              self.__combate = 'si'              self.__combate = 'si'
525          try:          try:
526              self.__subtipo =  doc_xml.childNodes[4].attributes["subtipo"].value              self.__subtipo =  extraer_atributo_xml(elem_propiedades,'subtipo')
527          except:          except:
528              self.__subtipo = 'sin_subtipo'              self.__subtipo = 'sin_subtipo'
529          self.__ocultabilidad = int(doc_xml.childNodes[4].attributes["ocultabilidad"].value)          self.__ocultabilidad = int(extraer_atributo_xml(elem_propiedades,'ocultabilidad'))
530                    
531    
532      def __parsear_descripcion(self, doc_xml):      def __parsear_descripcion(self, elem_descripcion):
533          """Extrae el texto y la dificultad asociada de los items de descripcion de la sala"""          """Extrae el texto y la dificultad asociada de los items de descripcion de la sala"""
534                    self.__descripcion = []
535          nodo_descripcion = doc_xml.childNodes[2]          elems_item = elem_descripcion.getElementsByTagName('item')
536    
537          # Limpiamos todos los subnodos de tipo Text, al igual          for elem_item in elems_item:
         # que hacíamos en la función __iniciar_parseador()  
         for nodo in nodo_descripcion.childNodes[:]:  
             if not 'Element:' in str(nodo).split():  
                 doc_xml.childNodes[2].childNodes.remove(nodo)  
           
         self.__descripcion = []  
   
         for nodo_item in nodo_descripcion.childNodes[:]:  
538    
539              texto_item = ""              texto_item = extraer_contenido_xml(elem_item)
540              for nodo_parrafo in nodo_item.childNodes[:]:              texto_item = " ".join(texto_item.split()) # elimina todos los espacios redundantes      
                 texto_item += nodo_parrafo.data.encode('ISO-8859-1')  
541                            
542              texto_item = " ".join(texto_item.split())              if elem_item.hasAttribute('dificultad'):
543                    try:
544                        dif_item = int(extraer_atributo_xml(elem_item,'dificultad'))
545                    except ValueError:
546                        raise ValueError("Error en sala " + self.__id +
547                            ". La dificultad de la descripción tiene que ser un número.")
548                    if not dif_item in range(0, 101):
549                        raise ValueError("Error en sala " + self.__id +
550                            ". La dificultad de la descripción tiene que ser de 0 a 100.")
551                else:
552                    dif_item = 0    
553                self.__descripcion.append({"dificultad": dif_item, "texto": texto_item})
554    
             if len(nodo_item._attrs) == 0:  
                 dif_item = 0  
             else:  
                 dif_item = int(nodo_item._attrs.get('dificultad').value)  
                   
             self.__descripcion.append({"dificultad": dif_item, "texto": texto_item})  
555    
556        
557      def __parsear_decorativos(self, doc_xml):      def __parsear_salidas(self, elem_salidas):  
         """Extrae el texto y la dificultad asociada de los items decorativos de la sala"""  
           
         nodo_decorativos = doc_xml.childNodes[3]  
   
         # Limpiamos todos los subnodos de tipo Text, al igual  
         # que hacíamos en la función __iniciar_parseador()  
         for nodo in nodo_decorativos.childNodes[:]:  
             if not 'Element:' in str(nodo).split():  
                 doc_xml.childNodes[2].childNodes.remove(nodo)  
           
         self.__decorativos = []  
   
         for nodo_item in nodo_decorativos.childNodes[:]:  
   
             nombre_item = nodo_item._attrs.get('nombre').value.encode('ISO-8859-1')  
             texto_item = nodo_item._attrs.get('texto').value.encode('ISO-8859-1')  
   
             if len(nodo_item._attrs) == 1:  
                 dif_item = 0  
             else:  
                 dif_item = int(nodo_item._attrs.get('dificultad').value)  
                   
             self.__decorativos.append({"nombre": nombre_item, "dificultad": dif_item, "texto": texto_item})  
   
     
     def __parsear_salidas(self, doc_xml):        
558          """Extrae toda la información de las salidas de la sala."""          """Extrae toda la información de las salidas de la sala."""
559                    limpiar_nodos_text_xml(elem_salidas)
560          nodo_salidas = doc_xml.childNodes[3]          self.__salidas = []
           
         # Limpiamos todos los subnodos de tipo Text, al igual  
         # que hacíamos en la función __iniciar_parseador()  
         for nodo in nodo_salidas.childNodes[:]:  
             if not 'Element:' in str(nodo).split():  
                 nodo_salidas.childNodes.remove(nodo)  
   
         self.__salidas = []  
561    
562          for nodo_salida in nodo_salidas.childNodes[:]:          for nodo_salida in elem_salidas.childNodes[:]:
563                            
564              direccion_salida = nodo_salida.nodeName.encode('ISO-8859-1')  # oeste, este, norte, etc.              direccion_salida = extraer_nombre_xml(nodo_salida)  # oeste, este, norte, etc.
565              try:              if nodo_salida.hasAttribute('dificultad'):
566                  dif_salida = int(nodo_salida._attrs.get('dificultad').value.encode('ISO-8859-1'))                  try:
567              except:                      dif_salida = int(extraer_atributo_xml(nodo_salida,'dificultad'))
568                  dif_salida = 0                  except ValueError:
569              try:                      raise ValueError("Error en sala " + self.__id +
570                  tipo_cierre_salida = nodo_salida._attrs.get('tipo_cierre').value.encode('ISO-8859-1')                               ". La dificultad de la salida tiene que ser un número.")
571              except:                  if not dif_salida in range(0, 101):
572                  tipo_cierre_salida = "ninguno"                      raise ValueError("Error en sala " + self.__id +
573              try:                              ". La dificultad de la salida tiene que ser de 0 a 100.")
574                  datos_cierre_salida = nodo_salida._attrs.get('datos_cierre').value.encode('ISO-8859-1')              else:
575              except:                  dif_salida = 0
576                  datos_cierre_salida = ""              #GPT: no gestiono lo siguiente con if pq no se las posibles excepciones que se pueden dar
577              try:              try:
578                  mensaje_cerrado_salida = nodo_salida._attrs.get('mensaje_cerrado').value.encode('ISO-8859-1')                  tipo_cierre_salida = extraer_atributo_xml(nodo_salida,'tipo_cierre')
579              except:              except:
580                  mensaje_cerrado_salida = "Algo te impide pasar"                  tipo_cierre_salida = "ninguno"
581                                try:
582              id_salida = nodo_salida._attrs.get('id').value.encode('ISO-8859-1')                  datos_cierre_salida = extraer_atributo_xml(nodo_salida,'datos_cierre')
583              desc_salida = nodo_salida.childNodes[0].data.encode('ISO-8859-1')              except:
584                    datos_cierre_salida = ""
585              self.__salidas.append({"direccion": direccion_salida,              try:
586                                     "dificultad": dif_salida,                  mensaje_cerrado_salida = extraer_atributo_xml(nodo_salida,'mensaje_cerrado')
587                                     "id": id_salida,              except:
588                                     "descripcion": desc_salida,                  mensaje_cerrado_salida = "Algo te impide pasar"
589                                     "tipo_cierre": tipo_cierre_salida,                  
590                                     "datos_cierre": datos_cierre_salida,              id_salida = extraer_atributo_xml(nodo_salida,'id')
591                desc_salida = extraer_contenido_xml(nodo_salida)
592    
593                self.__salidas.append({"direccion": direccion_salida,
594                                       "dificultad": dif_salida,
595                                       "id": id_salida,
596                                       "descripcion": desc_salida,
597                                       "tipo_cierre": tipo_cierre_salida,
598                                       "datos_cierre": datos_cierre_salida,
599                                     "mensaje_cerrado": mensaje_cerrado_salida})                                     "mensaje_cerrado": mensaje_cerrado_salida})
600    
601    
602      def __parsear_objetos(self, doc_xml):      def __parsear_objetos(self, elem_objetos):
603          """Extrae toda la información de los objetos que hay en la sala inicialmente."""          """Extrae toda la información de los objetos que hay en la sala inicialmente."""
604    
605          nodo_objetos = doc_xml.childNodes[5]          self.__objetos = []
606            elems_objeto = elem_objetos.getElementsByTagName('objeto')
607          # Limpiamos todos los subnodos de tipo Text, al igual      
608          # que hacíamos en la función __iniciar_parseador()          for elem_objeto in elems_objeto:
609          for nodo in nodo_objetos.childNodes[:]:          
610              if  'Element:' not in str(nodo).split():              id_objeto = extraer_atributo_xml(elem_objeto,'id')
611                  nodo_objetos.childNodes.remove(nodo)  #           desc_objeto = extraer_contenido_xml(elem_objeto)
612    #        desc_objeto= " ".join(texto_item.split()) # elimina todos los espacios redundantes
613          self.__objetos = []          
614                if elem_objeto.hasAttribute('cantidad'):
615          for nodo_objeto in nodo_objetos.childNodes[:]:                  try:
616                        cantidad_objeto = int(extraer_atributo_xml(elem_objeto,'cantidad'))
617              id_objeto = nodo_objeto._attrs.get('id').value.encode('ISO-8859-1')                  except ValueError:
618              try:                      raise ValueError("Error en sala " + self.__id +
619                  cantidad_objeto = int(nodo_objeto._attrs.get('cantidad').value)                           ". La cantidad del objeto tiene que ser un número.")
620              except:                  if cantidad_objeto <1:
621                  cantidad_objeto = 1                      raise ValueError("Error en sala " + self.__id +
622              try:                           ". La cantidad de un objeto tiene que ser un número mayor que cero.")
623                  max_objeto = int(nodo_objeto._attrs.get('maximo').value)              else:
624              except:                  cantidad_objeto=1
625                  max_objeto = cantidad_objeto                  
626              try:              if elem_objeto.hasAttribute('maximo'):
627                  prob_objeto = int(nodo_objeto._attrs.get('probabilidad').value)                  try:
628              except:                      max_objeto = int(extraer_atributo_xml(elem_objeto,'maximo'))
629                  prob_objeto = 0                  except ValueError:
630              try:                      raise ValueError("Error en sala " + self.__id +
631                  dif_objeto = int(nodo_objeto._attrs.get('dificultad').value)                           ". El máximo de un objeto tiene que ser un número.")
632              except:                  if max_objeto <1:
633                  dif_objeto = 0                      raise ValueError("Error en sala " + self.__id +
634              desc_objeto = nodo_objeto.childNodes[0].data.encode('ISO-8859-1')                           ". El máximo de un objeto tiene que ser un número mayor que cero.")
635                else:
636              instancias = []                  max_objeto = cantidad_objeto
637              for i in range(cantidad_objeto):              
638                      instancias.append(Objeto(id_objeto))              if elem_objeto.hasAttribute('probabilidad'):
639                    try:
640              self.__objetos.append({"id": id_objeto,                      prob_objeto = int(extraer_atributo_xml(elem_objeto,'probabilidad'))
641                                     "probabilidad": prob_objeto,                  except ValueError:
642                                     "maximo": max_objeto,                      raise ValueError("Error en sala " + self.__id +
643                                     "dificultad": dif_objeto,                               ". La probabilidad del objeto tiene que ser un número.")
644                                     "instancias": instancias})                  if not prob_objeto in range(0, 101):
645                        raise ValueError("Error en sala " + self.__id +
646                                 ". La probabilidad del objeto tiene que ser de 0 a 100.")
647                else:
648                    prob_objeto = 0  
649            
650                if elem_objeto.hasAttribute('dificultad'):
651                    try:
652                        dif_objeto = int(extraer_atributo_xml(elem_objeto,'dificultad'))
653                    except ValueError:
654                        raise ValueError("Error en sala " + self.__id +
655                                 ". La dificultad del objeto tiene que ser un número.")
656                    if not dif_objeto in range(0, 101):
657                        raise ValueError("Error en sala " + self.__id +
658                                 ". La dificultad del objeto tiene que ser de 0 a 100.")
659                else:
660                    dif_objeto = 0  
661    
662                    instancias = []
663                for i in range(cantidad_objeto):
664                    instancias.append(Objeto(id_objeto))
665    
666                self.__objetos.append({"id": id_objeto,
667                                       "probabilidad": prob_objeto,
668                           "maximo": max_objeto,
669                           "dificultad": dif_objeto,
670                           "instancias": instancias})
671                    
672    
673      def __parsear_encuentros(self, doc_xml):      def __parsear_encuentros(self, elem_encuentros):
674          """Extrae toda la información de los PNJs que hay en la sala inicialmente."""          """Extrae toda la información de los PNJs que hay en la sala inicialmente."""
675                    
676          nodo_encuentros = doc_xml.childNodes[6]          #limpiar_nodos_text_xml(elem_encuentros)
677            elems_encuentro = elem_encuentros.getElementsByTagName('encuentro')
678          # Limpiamos todos los subnodos de tipo Text, al igual          self.__encuentros=[]
679          # que hacíamos en la función __iniciar_parseador()  
680          for nodo in doc_xml.childNodes[6].childNodes[:]:          for elem_encuentro in elems_encuentro:
681              if 'Element:' not in str(nodo).split(): doc_xml.childNodes[6].childNodes.remove(nodo)              id_encuentro = extraer_atributo_xml(elem_encuentro,'id')
682                if elem_encuentro.hasAttribute('cantidad'):
683          self.__encuentros=[]                  try:
684                        cant_encuentro = int(extraer_atributo_xml(elem_encuentro,'cantidad'))
685          for nodo_encuentro in nodo_encuentros.childNodes[:]:                  except ValueError:
686              id_encuentro = nodo_encuentro._attrs.get('id').value.encode('ISO-8859-1')                      raise ValueError("Error en sala " + self.__id +
687              try:                           ". La cantidad de un encuentro tiene que ser un número.")
688                  cant_encuentro = int(nodo_encuentro._attrs.get('cantidad').value)                  if cant_encuentro <1:
689              except:                      raise ValueError("Error en sala " + self.__id +
690                  cant_encuentro = 1                           ". La cantidad de un encuentro tiene que ser un número mayor que cero.")
691              try:              else:
692                  max_encuentro = int(nodo_encuentro._attrs.get('maximo').value)                  cant_encuentro = 1
693              except:              if elem_encuentro.hasAttribute('maximo'):
694                  max_encuentro = 0                  try:
695              try:                      max_encuentro = int(extraer_atributo_xml(elem_encuentro,'maximo'))
696                  prob_encuentro = int(nodo_encuentro._attrs.get('probabilidad'))                  except ValueError:
697              except:                      raise ValueError("Error en sala " + self.__id +
698                  prob_encuentro = 0                           ". El máximo de un encuentro tiene que ser un número.")
699              try:                  if max_encuentro <1:
700                  dif_encuentro = int(nodo_encuentro._attrs.get('dificultad').value)                      raise ValueError("Error en sala " + self.__id +
701              except:                           ". El máximo de un encuentro tiene que ser un número mayor que cero.")
702                  dif_encuentro = 0              else:
703              desc_encuentro = nodo_encuentro.childNodes[0].data.encode('ISO-8859-1')                  max_encuentro = 0
704                if elem_encuentro.hasAttribute('probabilidad'):
705                    try:
706                        prob_encuentro = int(extraer_atributo_xml(elem_encuentro,'probabilidad'))
707                    except ValueError:
708                        raise ValueError("Error en sala " + self.__id +
709                                 ". La probabilidad del encuentro tiene que ser un número.")
710                    if not prob_encuentro in range(0, 101):
711                        raise ValueError("Error en sala " + self.__id +
712                                 ". La probabilidad del encuentro tiene que ser de 0 a 100.")
713                else:
714                    prob_encuentro = 0
715                if elem_encuentro.hasAttribute('dificultad'):
716                    try:
717                        dif_encuentro = int(extraer_atributo_xml(elem_encuentro,'dificultad'))
718                    except ValueError:
719                        raise ValueError("Error en sala " + self.__id +
720                                 ". La dificultad del encuentro tiene que ser un número.")
721                    if not dif_encuentro in range(0, 101):
722                        raise ValueError("Error en sala " + self.__id +
723                                 ". La dificultad del encuentro tiene que ser de 0 a 100.")
724                else:
725                    dif_encuentro = 0
726                desc_encuentro = extraer_contenido_xml(elem_encuentro)
727                            
728              self.__encuentros.append({"id": id_encuentro,              self.__encuentros.append({"id": id_encuentro,
729                                        "maximo": max_encuentro,                            "maximo": max_encuentro,
730                                        "probabilidad": prob_encuentro,                            "probabilidad": prob_encuentro,
731                                        "dificultad": dif_encuentro,                            "dificultad": dif_encuentro,
732                                        "descripcion": desc_encuentro})                            "descripcion": desc_encuentro})
733    
734              escribir("Vamos a crear " + str(cant_encuentro) + " pnjs")              escribir("Vamos a crear " + str(cant_encuentro) + " pnjs")
735              for i in range(cant_encuentro):              for i in range(cant_encuentro):
736                  id_unico = id_encuentro + '%' + PersonajeNoJugador.nuevo_id()                  id_unico = id_encuentro + '%' + PersonajeNoJugador.nuevo_id()
737                  escribir("Vamos a crear a " + id_unico)                  escribir("Vamos a crear a " + id_unico)
738                  self.__personajes[id_unico] = PersonajeNoJugador.nuevo(id_unico, self)                  self.__personajes[id_unico] = PersonajeNoJugador(id_unico, self)
739    
740    
741      # Métodos normales      # Métodos normales
# Line 759  class Sala(object): Line 861  class Sala(object):
861          return ocupado          return ocupado
862    
863    
864      def buscar_objeto(self, id_objeto, n_orden=1):      def coger_objeto(self, n_objeto, n_instancia):
865          """Localiza un objeto en la sala.          """Sacar una instancia de un objeto de la sala.
   
         - id_objeto es el identificador del objeto. Puede haber varios objetos distintos  
           con el mismo id  
         - n_orden sirve para distinguir el objeto si hay mas de uno con el mismo id  
866    
867          Devuelve el indice dentro de la lista de objetos de la sala que apunta al objeto buscado.          n_objeto es el numero de orden dentro de los objetos de la sala, y n_instancia
868            es el numero de la instancia, ambos empezando por cero.
869    
870          Lanza ExcepcionDeJuego si no se encuentra.          Devuelve una instancia de clase Objeto.
871    
872          Requiere:          Requiere:
873              id_objeto != None              n_objeto in range(0, len(self.objetos)-1)
874              n_orden >= 1              n_instancia in range(0, len(self.objetos[n_objeto]["instancias"])-1)
   
         Asegura:  
             return in range(0, len(self.objetos))  
         """  
         encontrados = 0  
         n_objeto = -1  
   
         for objeto in self.__objetos:  
             n_objeto = n_objeto + 1  
             if len(objeto["instancias"]) > 0:  
                 if normalizar_id(id_objeto) == extraer_id(objeto["instancias"][0].nombre):  
                     encontrados = encontrados + 1  
                     if encontrados == n_orden:  
                         break  
                       
         if encontrados == 0:  
             raise ExcepcionDeJuego("No hay en la sala ningún objeto con identificativo " +  
                                    id_objeto)  
         elif encontrados < n_orden:  
             raise ExcepcionDeJuego("No hay en la sala suficientes objetos con identificativo " +  
                                    id_objeto + ", solo hay " + str(encontrados))  
   
         else:  
             return n_objeto  
   
   
     def coger(self, n_objeto, n_instancia=1, cantidad=1):  
         """Sacar una o varias instancias de un objeto de la sala.  
           
         - n_objeto es el número de orden del objeto dentro de la sala  
         - n_instancia es el número de orden de la primera instancia a extraer  
         - cantidad es el número de instancias a extraer  
   
         Devuelve una lista con las instancias extraidas.  
   
         Lanza ExcepcionDeJuego si no puede sacarlas (por ejemplo, se han pedido  
         más instancias de las que hay).  
   
         Requiere:  
             n_objeto in range(0, len(self.objetos))  
             n_instancia >= 1  
             cantidad >= 1  
875    
876          Asegura:          Asegura:
877              return != None              return != None
878              len(return) == cantidad          """
         """  
879          objeto = self.__objetos[n_objeto]          objeto = self.__objetos[n_objeto]
880    
881          if (n_instancia + cantidad - 1) > len(objeto["instancias"]):          instancia = objeto["instancias"][n_instancia]
             raise ExcepcionDeJuego("No hay " + str(n_instancia + cantidad - 1) +  
                                    " instancias de ese objeto, solo hay " +  
                                    str(len(objeto["instancias"])))  
   
         objetos_cogidos = []  
   
         instancias = objeto["instancias"]  
         for i in range(0, cantidad):  
             objetos_cogidos.append(instancias[n_instancia-1])  
             instancias[n_instancia-1].activar()  
             del instancias[n_instancia-1]  
882    
883          if len(instancias) == 0 and objeto["probabilidad"] == 0:          del objeto["instancias"][n_instancia]
884            if len(objeto["instancias"]) == 0 and objeto["probabilidad"] == 0:
885              del self.__objetos[n_objeto]              del self.__objetos[n_objeto]
886    
887          return objetos_cogidos          instancia.activar()
   
888    
889            return instancia
890    
 #%%    def coger(self, id_objeto, cantidad=1, n_orden=1, n_instancia=1):  
 #%%     """Extraer una o mas instancias de un objeto de la sala.  
 #%%  
 #%%     - id_objeto es el identificador del objeto. Puede haber varios objetos distintos  
 #%%       con el mismo id  
 #%%     - cantidad es el numero de instancias a extraer  
 #%%     - n_orden sirve para distinguir el objeto si hay mas de uno con el mismo id  
 #%%     - n_instancia es para elegir una instancia concreta, si hay mas de una  
 #%%  
 #%%     Devuelve una lista con todas las instancias extraidas.  
 #%%  
 #%%     Lanza ExcepcionDeJuego si no se puede coger (el id no existe, se piden mas instancias de las  
 #%%     que hay, etc.)  
 #%%  
 #%%     Requiere:  
 #%%         id_objeto != None  
 #%%         cantidad >= 1  
 #%%         n_orden >= 1  
 #%%         n_instancia >= 1  
 #%%  
 #%%     Asegura:  
 #%%         return != None  
 #%%     """  
 #%%     objetos_extraidos = []  
 #%%     encontrados = 0  
 #%%     n_objeto = -1  
 #%%  
 #%%     for objeto in self.__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):  
 #%%                         raise ExcepcionDeJuego("No hay " + str(n_instancia + cantidad - 1) +  
 #%%                                                " instancias de ese objeto, solo hay " +  
 #%%                                                str(len(instancias)))  
 #%%                     else:  
 #%%                         for i in range(0, cantidad):  
 #%%                             instancia = self.coger_un_objeto(n_objeto, n_instancia - 1)  
 #%%                             objetos_extraidos.append(instancia)  
 #%%  
 #%%                     break  
 #%%                  
 #%%     if encontrados == 0:  
 #%%            raise ExcepcionDeJuego("No hay en la sala ningún objeto con identificativo " +  
 #%%                                id_objeto)  
 #%%     elif encontrados < n_orden:  
 #%%         raise ExcepcionDeJuego("No hay en la sala suficientes objetos con identificativo " +  
 #%%                                id_objeto + ", solo hay " + str(encontrados))  
 #%%  
 #%%  
 #%%    def coger_un_objeto(self, n_objeto, n_instancia):  
 #%%     """Sacar una instancia de un objeto de la sala.  
 #%%  
 #%%     n_objeto es el numero de orden dentro de los objetos de la sala, y n_instancia  
 #%%     es el numero de la instancia, ambos empezando por cero.  
 #%%  
 #%%     Devuelve una instancia de clase Objeto.  
 #%%  
 #%%     Requiere:  
 #%%         n_objeto in range(0, len(self.objetos)-1)  
 #%%         n_instancia in range(0, len(self.objetos[n_objeto]["instancias"])-1)  
 #%%  
 #%%     Asegura:  
 #%%         return != None  
 #%%     """  
 #%%     objeto = self.__objetos[n_objeto]  
 #%%  
 #%%     instancia = objeto["instancias"][n_instancia]  
 #%%  
 #%%     del objeto["instancias"][n_instancia]  
 #%%     if len(objeto["instancias"]) == 0 and objeto["probabilidad"] == 0:  
 #%%         del self.__objetos[n_objeto]  
 #%%  
 #%%     instancia.activar()  
 #%%  
 #%%     return instancia  
891    
892        def dejar_objeto(self, instancia, dificultad = 0):
893            """Soltar un objeto en la sala.
894    
895      def dejar(self, objetos, dificultad = 0):          instancia es de clase Objeto. Si ya habia mas instancias con el mismo id en la sala,
896          """Soltar una o varias instancias de un objeto en la sala.          se añade a la lista, y si no, se crea un item nuevo en self.objetos.
   
         Si dificultad != 0, el objeto queda escondido (excepto si ya había  
         más instancias de ese mismo objeto anteriormente en la sala).  
897    
898          Requiere:          Requiere:
899              objetos != None              instancia != None
             len(objetos) >= 1  
900              dificultad in range(0, 100)              dificultad in range(0, 100)
901          """          """
902          encontrado = 0          encontrado = 0
903                    
904          for objeto in self.__objetos:          for objeto in self.__objetos:
905              if objeto["id"] == objetos[0].id:              if objeto["id"] == instancia.id:
906                  encontrado = 1                  encontrado = 1
907                  objeto["instancias"].extend(objetos)                  objeto["instancias"].append(instancia)
908                  break                  break
909    
910          if not encontrado:          if not encontrado:
# Line 950  class Sala(object): Line 912  class Sala(object):
912                                     "probabilidad":0,                                     "probabilidad":0,
913                                     "maximo":0,                                     "maximo":0,
914                                     "dificultad":dificultad,                                     "dificultad":dificultad,
915                                     "instancias":objetos})                                     "instancias":[instancia]})
   
   
 #%%    def dejar_objeto(self, instancia, dificultad = 0):  
 #%%     """Soltar un objeto en la sala.  
 #%%  
 #%%     instancia es de clase Objeto. Si ya habia mas instancias con el mismo id en la sala,  
 #%%     se añade a la lista, y si no, se crea un item nuevo en self.objetos.  
 #%%  
 #%%     Requiere:  
 #%%         instancia != None  
 #%%         dificultad in range(0, 100)  
 #%%     """  
 #%%     encontrado = 0  
 #%%          
 #%%     for objeto in self.__objetos:  
 #%%         if objeto["id"] == instancia.id:  
 #%%             encontrado = 1  
 #%%             objeto["instancias"].append(instancia)  
 #%%             break  
 #%%  
 #%%     if not encontrado:  
 #%%         self.__objetos.append({"id":instancia.id,  
 #%%                                "probabilidad":0,  
 #%%                                "maximo":0,  
 #%%                                "dificultad":dificultad,  
 #%%                                "instancias":[instancia]})  
916    
917    
918      def salida_cerrada(self, id_sala_destino):      def salida_cerrada(self, id_sala_destino):
# Line 1036  class Sala(object): Line 972  class Sala(object):
972                          return (id_llave, salida["mensaje_cerrado"])                          return (id_llave, salida["mensaje_cerrado"])
973    
974    
     def cambiar_aura(self, puntos):  
         """Modifica el valor de la propiedad aura."""  
         self.__aura += puntos  
   
   
     def ambiente(self, texto, rango_salas=0):  
         """Ocurre algo que lo ven todos los personajes en esta sala y adyacentes.  
   
         rango_de_salas es la distancia a la que se percibe el suceso (0 = sólo sala origen,  
         1 = salas a distancia 1, etc.)  
           
         Requiere:  
             texto != None  
             rango_de_salas >= 0  
         """  
         sala = self  
         # Ahora tengo que buscar por ahí el algoritmo de recorrido de grafos sin repeticiones,  
         # con distancia limitada, pero no tengo ganas. Ya lo haré un día de estos.  
         for personaje in [ p for p in sala.personajes.values() if p.controlador != None]:  
             personaje.controlador.suceso_entorno(texto)  
   
   
975      def salvar(self):      def salvar(self):
976          """Graba en un fichero de salas la sala con todo su contenido."""          """Graba en un fichero de salas la sala con todo su contenido."""
977                    

Legend:
Removed from v.2.8  
changed lines
  Added in v.2.9

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26