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 |
|
|
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: |
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: |
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: |
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: |
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: |
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 |
|
|
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 |
|
|
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 |
|
|
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 |
|
|
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: |
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: |
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: |
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 |
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: |
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): |
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 |
|
|