40 |
"""Un objeto dentro del juego. |
"""Un objeto dentro del juego. |
41 |
|
|
42 |
Contiene los siguientes atributos: |
Contiene los siguientes atributos: |
43 |
- autor (string): identifica al autor del objeto. |
- __id (string): identifica univocamente al objeto. No puede contener espacios. |
44 |
- version (int): la versión del tipo de objeto. |
- __version (int): la versión del sistema de objetos. |
45 |
- comentario (string): un metacomentario acerca del objeto. |
- __autor (string): identifica al autor del objeto. |
46 |
- area (string): el area a la que pertenece el objeto, si es que lo necesita. |
- __comentario (string): un metacomentario acerca del objeto. |
47 |
- id (string): identifica univocamente al objeto |
- __area (string): el area a la que pertenece el objeto, si es que lo necesita. |
48 |
- nombre (string): Una breve frase informando de qué es el objeto. |
- __nombre (string): Una breve frase informando de qué es el objeto. |
49 |
- descripcion ({String:any}[]): una lista de diccionarios que contiene cada uno: |
- __descripcion ({String:any}[]): una lista de diccionarios que contiene cada uno: |
50 |
- "dificultad" (int): de 1 a 100 |
- "dificultad" (int): de 1 a 100 |
51 |
- "texto" (string): el contenido del item de descripcion |
- "texto" (string): el contenido del item de descripcion |
52 |
- tipo (string): el tipo de material del objeto. |
- __tipo (string): el tipo de material del objeto. |
53 |
- categoria (string): el tipo de uso generico del objeto. |
- __categoria (string): el tipo de uso generico del objeto. |
54 |
- peso (float): en kilos |
- __peso (float): en kilos |
55 |
- volumen (float): en relación a 1 unidad de persona. |
- __volumen (float): en relación a 1 unidad de persona. |
56 |
- cargas (int): el número de veces que puede ser usado antes de destruirse o |
- __cargas (int): el número de veces que puede ser usado antes de destruirse o |
57 |
volverse inservible. El valor 0 indica que no tiene limite. |
volverse inservible. El valor 0 indica que no tiene limite. |
58 |
- valor (int): en monedas de estaño. |
- __valor (int): en monedas de estaño. |
59 |
- estado (int): de 0 a 100. |
- __estado (int): de 0 a 100. |
60 |
- aura (int): de 0 a 100 |
- __aura (int): de 0 a 100 |
61 |
- usos ({String:any}[]): lista de usos del objeto, siendo cada uso un diccionario: |
- __usos ({string:any}[]): lista de usos del objeto, siendo cada uso un diccionario: |
62 |
- "tipo" (string): el tipo de uso ("comer", "poner", "lanzar", etc.) |
- "tipo" (string): el tipo de uso ("comer", "poner", "lanzar", etc.) |
63 |
- "posicion" (string): si el uso es "poner", en que parte del cuerpo se pone |
- "posicion" (string): si el uso es "poner", en que parte del cuerpo se pone |
64 |
- "gasto" (int): el numero de cargas que consume cada uso |
- "gasto" (int): el numero de cargas que consume cada uso |
65 |
- "msg" (string): el mensaje que aparece cuando se usa |
- "msg" (string): el mensaje que aparece cuando se usa |
66 |
- "duracion" (int): el numero de segundos que dura el efecto (0 = indeterminado) |
- "duracion" (int): el numero de segundos que dura el efecto (0 = indeterminado) |
67 |
- "requisitos"... |
- "requisitos" ({string:any}[]): lista de requisitos del uso, siendo cada requisito |
68 |
- "efectos"... |
un diccionario: |
69 |
|
- "atributo" (string): el atributo a comprobar |
70 |
|
- "valor" (int): el valor mínimo que deberá tener el atributo |
71 |
|
- "msg" (string): el mensaje que sale si el atributo no llega al mínimo |
72 |
|
- "efectos" ({string:any}[]): lista de efectos que produce el uso, siendo cada |
73 |
|
efecto un diccionario: |
74 |
|
- "atributo" (string): el atributo a modificar |
75 |
|
- "valor" (int): el número de puntos que sube o baja (si es negativo) |
76 |
|
- "duracion" (int): duración del efecto en segundos (0 = ilimitado) |
77 |
|
- "msg" (string): el mensaje que sale cuando ocurre el efecto |
78 |
|
- __fecha_fichero (int): fecha de la ultima modificacion del fichero de descripcion |
79 |
|
|
80 |
Al instanciar un objeto, se crea nuevo y se lee desde el fichero de descripcion de objeto, |
Al instanciar un objeto, se crea nuevo y se lee desde el fichero de descripcion de objeto, |
81 |
poniendola en su estado inicial (en una sala). Esta instancia podrá pasar a manos de pjs y pnjs. |
poniendolo en su estado inicial. Esta instancia podrá pasar a manos de pjs y pnjs, y se |
82 |
|
puede salvar a disco junto con la sala o el personaje que lo contiene. |
83 |
|
|
84 |
|
|
85 |
Invariantes: |
Invariantes: |
86 |
id != None |
__id != None |
87 |
version != None |
__version != None |
88 |
autor != None |
__autor != None |
89 |
comentario != None |
__comentario != None |
90 |
area != None |
__area != None |
91 |
nombre != None |
__nombre != None |
92 |
tipo != None |
__tipo != None |
93 |
categoria != None |
__categoria != None |
94 |
peso > 0 |
__peso > 0 |
95 |
volumen > 0 |
__volumen > 0 |
96 |
cargas > 0 |
__cargas >= 0 |
97 |
valor > 0 |
__valor > 0 |
98 |
estado in range(0,100) |
__estado in range(0,100) |
99 |
aura in range(0,100) |
__aura in range(0,100) |
100 |
|
|
101 |
descripcion != None |
__tipo in TIPOS_DE_MATERIAL |
102 |
len(descripcion) >= 0 |
__categoria in CATEGORIAS |
103 |
descripcion[i]["dificultad"] in range(0,100) |
|
104 |
descripcion[i]["texto"] != None |
__descripcion != None |
105 |
|
len(__descripcion) >= 0 |
106 |
requisitos != None |
__descripcion[i]["dificultad"] in range(0,100) |
107 |
len(requisitos) >= 0 |
__descripcion[i]["texto"] != None |
108 |
|
|
109 |
efectos != None |
__usos != None |
110 |
len(efectos) >= 0 |
len(__usos) >= 0 |
111 |
|
__usos[i]["tipo"] in USOS |
112 |
|
__usos[i]["posicion"] in POSICIONES |
113 |
|
__usos[i]["gasto"] >= 0 |
114 |
|
__usos[i]["msg"] != None |
115 |
|
__usos[i]["duracion"] >= 0 |
116 |
|
__usos[i]["requisitos"] != None |
117 |
|
__usos[i]["requisitos"][j]["atributo"] != None |
118 |
|
__usos[i]["requisitos"][j]["valor"] in range(0,100) |
119 |
|
__usos[i]["requisitos"][j]["msg"] != None |
120 |
|
__usos[i]["efectos"] != None |
121 |
|
__usos[i]["efectos"][k]["atributo"] != None |
122 |
|
__usos[i]["efectos"][k]["duracion"] >= 0 |
123 |
|
__usos[i]["efectos"][k]["msg"] != None |
124 |
|
|
125 |
|
__fecha_fichero >= 0 |
126 |
""" |
""" |
127 |
|
|
128 |
|
# Version del sistema de descripciones de objeto (se incrementa cada vez que cambia |
129 |
|
# el formato de los ficheros de desc_objetos) |
130 |
|
VERSION_DESC_OBJETO = '1.0' |
131 |
|
|
132 |
|
# Version del sistema de objetos (se incrementa cada vez que varian los atributos |
133 |
|
# de la clase Objeto) |
134 |
|
VERSION_OBJETO = '1.0' |
135 |
|
|
136 |
DIR_DESC_OBJETOS = 'desc_objetos' |
DIR_DESC_OBJETOS = 'desc_objetos' |
137 |
DIR_OBJETOS = 'objetos' |
EXT_DESC_OBJETOS = '.xml' |
138 |
|
|
139 |
|
TIPOS_DE_MATERIAL = [ 'madera', 'metal', 'cristal', 'piel', 'tejido', 'piedra', |
140 |
|
'organico', 'cera', 'liquido', 'barro' ] |
141 |
|
|
142 |
|
CATEGORIAS = [ 'mobiliario', 'arma', 'recipiente', 'joya', 'armadura', 'herramienta', |
143 |
|
'vestimenta', 'escritura', 'recipìente', 'comestible', 'accesorio' ] |
144 |
|
|
145 |
def __init__(self, archivo): |
USOS = [ 'comer', 'beber', 'poner', 'lanzar', 'usar' ] |
146 |
|
|
147 |
"""Método inicial para leer los datos de un fichero de objeto""" |
POSICIONES = [ 'cabeza', 'cuello', 'tronco', 'brazo-izq', 'brazo-der', 'mano-izq', |
148 |
|
'mano-der', 'dos-manos', 'piernas', 'tobillo-izq', 'tobillo-der', |
149 |
|
'pie-izq', 'pie-der' ] |
150 |
|
|
|
self.id = archivo |
|
|
self.archivo=archivo+".xml" |
|
|
self.archivo=os.path.join(Objeto.DIR_DESC_OBJETOS, self.archivo) |
|
|
print self.archivo |
|
|
fuente = open(self.archivo) |
|
151 |
|
|
152 |
self.source = minidom.parse(fuente).documentElement |
def __init__(self, id): |
153 |
fuente.close() |
"""Crea un objeto nuevo a partir de un fichero de descripcion de objeto. |
154 |
|
|
155 |
|
Requiere: |
156 |
|
id != None |
157 |
|
id corresponde con un fichero existente |
158 |
|
""" |
159 |
|
|
160 |
|
self.__id = id |
161 |
|
self.__inicializar_objeto() |
162 |
|
|
|
self.iniciar_parseador(self.source) |
|
163 |
|
|
164 |
self.parsear_objeto(self.source) |
def id(self): return self.__id |
165 |
self.parsear_id(self.source) |
def version(self): return self.__version |
166 |
self.parsear_nombre(self.source) |
def autor(self): return self.__autor |
167 |
self.parsear_descripcion(self.source) |
def comentario(self): return self.__comentario |
168 |
self.parsear_propiedades(self.source) |
def area(self): return self.__area |
169 |
self.parsear_usos(self.source) |
def nombre(self): return self.__nombre |
170 |
|
def descripcion(self): return self.__descripcion |
171 |
|
def tipo(self): return self.__tipo |
172 |
|
def categoria(self): return self.__categoria |
173 |
|
def peso(self): return self.__peso |
174 |
|
def volumen(self): return self.__volumen |
175 |
|
def cargas(self): return self.__cargas |
176 |
|
def valor(self): return self.__valor |
177 |
|
def estado(self): return self.__estado |
178 |
|
def aura(self): return self.__aura |
179 |
|
def usos(self): return self.__usos |
180 |
|
|
181 |
|
|
182 |
|
def __inicializar_objeto(self): |
183 |
|
"""Rellena todos los datos del objeto a partir de su fichero de descripcion.""" |
184 |
|
|
185 |
|
archivo = os.path.join(Objeto.DIR_DESC_OBJETOS, self.__id + Objeto.EXT_DESC_OBJETOS) |
186 |
|
stream = open(archivo) |
187 |
|
doc_xml = minidom.parse(stream).documentElement |
188 |
|
stream.close() |
189 |
|
|
190 |
del self.source |
self.__fecha_fichero = os.path.getmtime(archivo) |
|
del self.usos_posibles |
|
191 |
|
|
192 |
|
self.__iniciar_parseador(doc_xml) |
193 |
|
|
194 |
|
self.__parsear_objeto(doc_xml) |
195 |
|
self.__parsear_id(doc_xml) |
196 |
|
self.__parsear_nombre(doc_xml) |
197 |
|
self.__parsear_descripcion(doc_xml) |
198 |
|
self.__parsear_propiedades(doc_xml) |
199 |
|
self.__parsear_usos(doc_xml) |
200 |
|
|
201 |
|
|
202 |
def iniciar_parseador(self, fuente): |
def __iniciar_parseador(self, doc_xml): |
203 |
"""Esta función borra todos los nodos de tipo Text de un |
"""Esta función borra todos los nodos de tipo Text de un |
204 |
elemento DOM""" |
elemento DOM""" |
205 |
|
|
206 |
for node in fuente.childNodes[:]: |
for nodo in doc_xml.childNodes[:]: |
207 |
if not 'Element:' in str(node).split(): fuente.childNodes.remove(node) |
if not 'Element:' in str(nodo).split(): |
208 |
|
doc_xml.childNodes.remove(nodo) |
209 |
|
|
210 |
|
|
211 |
def parsear_objeto(self, fuente): |
def __parsear_objeto(self, doc_xml): |
212 |
"""Extrae la información del elemento objeto: autor, version, comentario, area.""" |
"""Extrae la información del elemento objeto: autor, version, comentario, area.""" |
213 |
|
|
214 |
self.autor = fuente.attributes["autor"].value.encode('ISO-8859-1') |
version_desc_objeto = doc_xml.attributes["version"].value.encode('ISO-8859-1') |
215 |
self.version = fuente.attributes["version"].value.encode('ISO-8859-1') |
|
216 |
|
if version_desc_objeto != Objeto.VERSION_DESC_OBJETO: |
217 |
|
raise ValueError("Version incorrecta del fichero descriptor de objeto " + |
218 |
|
self.__id + ": " + version_desc_objeto + " cuando se esperaba " + |
219 |
|
Objeto.VERSION_DESC_OBJETO) |
220 |
|
|
221 |
|
self.__version = Objeto.VERSION_OBJETO |
222 |
|
|
223 |
|
self.__autor = doc_xml.attributes["autor"].value.encode('ISO-8859-1') |
224 |
try: |
try: |
225 |
self.comentario = fuente.attributes["comentario"].value.encode('ISO-8859-1') |
self.__comentario = doc_xml.attributes["comentario"].value.encode('ISO-8859-1') |
226 |
except: |
except: |
227 |
self.comentario = "" |
self.__comentario = "" |
228 |
try: |
try: |
229 |
self.area = fuente.attributes["area"].value.encode('ISO-8859-1') |
self.__area = doc_xml.attributes["area"].value.encode('ISO-8859-1') |
230 |
except: |
except: |
231 |
self.area = "" |
self.__area = "" |
232 |
|
|
233 |
|
|
234 |
def parsear_id(self, fuente): |
def __parsear_id(self, doc_xml): |
235 |
"""Extrae el id del objeto""" |
"""Extrae el id del objeto""" |
236 |
|
id_fichero = doc_xml.childNodes[0].childNodes[0].data.encode('ISO-8859-1') |
237 |
|
if id_fichero != self.__id: |
238 |
|
raise ValueError("El id no coincide con el nombre del fichero") |
239 |
|
|
240 |
self.id=fuente.childNodes[0].childNodes[0].data.encode('ISO-8859-1') |
|
241 |
|
def __parsear_nombre(self, doc_xml): |
|
def parsear_nombre(self, fuente): |
|
242 |
"""Extrae el nombre del objeto""" |
"""Extrae el nombre del objeto""" |
243 |
|
self.__nombre=doc_xml.childNodes[1].childNodes[0].data.encode('ISO-8859-1') |
|
self.nombre=fuente.childNodes[1].childNodes[0].data.encode('ISO-8859-1') |
|
244 |
|
|
245 |
|
|
246 |
def parsear_descripcion(self, fuente): |
def __parsear_descripcion(self, doc_xml): |
247 |
"""Extrae el texto y la dificultad asociada de los items |
"""Extrae el texto y la dificultad asociada de los items |
248 |
de descripcion del objeto""" |
de descripcion del objeto""" |
249 |
|
|
250 |
|
nodo_descripcion = doc_xml.childNodes[2] |
251 |
|
|
252 |
for node in fuente.childNodes[2].childNodes[:]: |
# Limpiamos todos los subnodos de tipo Text, al igual |
253 |
if not 'Element:' in str(node).split(): |
# que hacíamos en la función __iniciar_parseador() |
254 |
fuente.childNodes[2].childNodes.remove(node) |
for nodo in nodo_descripcion.childNodes[:]: |
255 |
|
if not 'Element:' in str(nodo).split(): |
256 |
|
doc_xml.childNodes[2].childNodes.remove(nodo) |
257 |
|
|
258 |
self.descripcion=[] |
self.__descripcion = [] |
259 |
|
|
260 |
nodo_descripcion=fuente.childNodes[2] |
for nodo_item in nodo_descripcion.childNodes[:]: |
261 |
|
|
|
for item in nodo_descripcion.childNodes[:]: |
|
262 |
texto_item="" |
texto_item="" |
263 |
for frase in item.childNodes[:]: |
for nodo_parrafo in nodo_item.childNodes[:]: |
264 |
frase.data=frase.data.encode('ISO-8859-1') |
texto_item += nodo_parrafo.data.encode('ISO-8859-1') |
|
texto_item=texto_item+frase.data |
|
265 |
|
|
266 |
texto_item = " ".join(texto_item.split()) |
texto_item = " ".join(texto_item.split()) |
267 |
|
|
268 |
if item._attrs == {}: dif_item = 0 |
if len(nodo_item._attrs) == 0: |
269 |
|
dif_item = 0 |
270 |
else: |
else: |
271 |
dif_item=int(item._attrs.get('dificultad').value) |
dif_item = int(nodo_item._attrs.get('dificultad').value) |
272 |
|
|
273 |
self.descripcion.append({"dificultad":dif_item,"texto":texto_item}) |
self.__descripcion.append({"dificultad":dif_item, "texto":texto_item}) |
274 |
|
|
275 |
|
|
276 |
def parsear_propiedades(self, fuente): |
def __parsear_propiedades(self, doc_xml): |
277 |
|
"""Extrae la información de las propiedades generales: tipo, categoria, peso, |
278 |
|
volumen, cargas, valor, estado, aura.""" |
279 |
|
|
280 |
|
self.__tipo = doc_xml.childNodes[3].attributes["tipo"].value.encode('ISO-8859-1') |
281 |
|
self.__categoria = doc_xml.childNodes[3].attributes["categoria"].value.encode('ISO-8859-1') |
282 |
|
self.__peso = float(doc_xml.childNodes[3].attributes["peso"].value) |
283 |
|
self.__volumen = float(doc_xml.childNodes[3].attributes["volumen"].value) |
284 |
try: |
try: |
285 |
self.tipo=fuente.childNodes[3].attributes["tipo"].value.encode('ISO-8859-1') |
self.__cargas = int(doc_xml.childNodes[3].attributes["cargas"].value) |
|
except: |
|
|
self.tipo="" |
|
|
try: |
|
|
self.categoria=fuente.childNodes[3].attributes["categoria"].value.encode('ISO-8859-1') |
|
|
except: |
|
|
self.categoria="" |
|
|
self.peso=float(fuente.childNodes[3].attributes["peso"].value) |
|
|
self.volumen=float(fuente.childNodes[3].attributes["volumen"].value) |
|
|
try: |
|
|
self.cargas=int(fuente.childNodes[3].attributes["cargas"].value) |
|
286 |
except: |
except: |
287 |
self.cargas=1 |
self.__cargas = 1 |
288 |
self.valor=int(fuente.childNodes[3].attributes["valor"].value) |
self.__valor = int(doc_xml.childNodes[3].attributes["valor"].value) |
289 |
self.estado=int(fuente.childNodes[3].attributes["estado"].value) |
self.__estado = int(doc_xml.childNodes[3].attributes["estado"].value) |
290 |
self.aura=int(fuente.childNodes[3].attributes["aura"].value) |
self.__aura = int(doc_xml.childNodes[3].attributes["aura"].value) |
291 |
|
|
292 |
|
|
293 |
def parsear_usos(self, fuente): |
def __parsear_usos(self, doc_xml): |
294 |
|
"""Extrae toda la información de los usos del objeto.""" |
295 |
|
|
296 |
|
nodo_usos = doc_xml.childNodes[4] |
297 |
|
|
298 |
|
# Limpiamos todos los subnodos de tipo Text, al igual |
299 |
|
# que hacíamos en la función __iniciar_parseador() |
300 |
|
for nodo in nodo_usos.childNodes[:]: |
301 |
|
if not 'Element:' in str(nodo).split(): |
302 |
|
nodo_usos.childNodes.remove(nodo) |
303 |
|
|
304 |
for node in fuente.childNodes[4].childNodes[:]: |
self.__usos = [] |
|
if 'Element:' not in str(node).split(): fuente.childNodes[4].childNodes.remove(node) |
|
305 |
|
|
306 |
self.usos_posibles=fuente.childNodes[4] |
for nodo_uso in nodo_usos.childNodes[:]: |
307 |
|
|
308 |
self.usos=[] |
uso_tipo = nodo_uso._attrs.get('tipo').value.encode('ISO-8859-1') |
|
for node in self.usos_posibles.childNodes[:]: |
|
309 |
try: |
try: |
310 |
uso_descripcion=node.data.value.encode('ISO-8859-1') |
uso_posicion = nodo_uso._attrs.get('posicion').value.encode('ISO-8859-1') |
311 |
except: uso_descripcion = 'Uso desconocido o evidente' |
except: |
312 |
|
uso_posicion = '' |
313 |
try: |
try: |
314 |
uso_tipo=node._attrs.get('tipo').value.encode('ISO-8859-1') |
uso_gasto = int(nodo_uso._attrs.get('gasto').value.encode('ISO-8859-1')) |
315 |
except: print 'algo anda mal, este uso de objeto no tiene tipo!!' |
except: |
316 |
|
uso_gasto = 0 |
317 |
try: |
try: |
318 |
uso_posicion=node._attrs.get('posicion').value.encode('ISO-8859-1') |
uso_msg = nodo_uso._attrs.get('msg').value.encode('ISO-8859-1') |
319 |
except: uso_posicion='mano_der' |
except: |
320 |
|
if uso_tipo == 'comer': |
321 |
|
uso_msg = 'Te comes ' + self.__nombre |
322 |
|
elif uso_tipo == 'beber': |
323 |
|
uso_msg = 'Bebes ' + self.__nombre |
324 |
|
elif uso_tipo == 'poner': |
325 |
|
uso_msg = 'Te pones ' + self.__nombre + ' en ' + uso_posicion |
326 |
|
elif uso_tipo == 'lanzar': |
327 |
|
uso_msg = 'Arrojas ' + self.__nombre |
328 |
|
else: |
329 |
|
uso_msg = 'Usas ' + self.__nombre |
330 |
try: |
try: |
331 |
uso_gasto=int(node._attrs.get('gasto').value.encode('ISO-8859-1')) |
uso_duracion = int(nodo_uso._attrs.get('duracion').value.encode('ISO-8859-1')) |
332 |
except: uso_gasto='1' |
except: |
333 |
|
uso_duracion = 0 |
334 |
uso_efectos_requisitos = node.childNodes[:] |
|
335 |
for node in uso_efectos_requisitos: |
# Limpiamos todos los subnodos de tipo Text del siguiente |
336 |
if 'Element:' not in str(node).split(): uso_efectos_requisitos.remove(node) |
# nivel del arbol xml |
337 |
efectos = [] |
for nodo in nodo_uso.childNodes[:]: |
338 |
requisitos = [] |
if not 'Element:' in str(nodo).split(): |
339 |
for node in uso_efectos_requisitos[:]: |
nodo_uso.childNodes.remove(nodo) |
340 |
if str(node).find('efecto') > -1: |
|
341 |
efectos.append({'atributo':node._attrs.get('atributo'),'valor':node._attrs.get('valor'),'msg':node._attrs.get('msg'),'duracion':node._attrs.get('duracion')}) |
uso_requisitos = [] |
342 |
elif str(node).find('requisito') > -1: |
uso_efectos = [] |
343 |
requisitos.append({'atributo':node._attrs.get('atributo'),'valor':node._attrs.get('valor'),'msg':node._attrs.get('msg')}) |
|
344 |
else: |
for nodo_requi_efe in nodo_uso.childNodes[:]: |
345 |
pass |
|
346 |
|
if nodo_requi_efe.nodeName.encode('ISO-8859-1') == 'requisito': |
347 |
self.usos.append({'descripcion':uso_descripcion,'tipo':uso_tipo,'posicion':uso_posicion,'gasto':uso_gasto,'requisitos':requisitos,'efectos':efectos}) |
|
348 |
del uso_descripcion,uso_tipo,uso_posicion,uso_gasto,uso_efectos_requisitos |
requisito_atrib = nodo_requi_efe._attrs.get('atributo').value.encode('ISO-8859-1') |
349 |
|
requisito_valor = int(nodo_requi_efe._attrs.get('valor').value.encode('ISO-8859-1')) |
350 |
|
try: |
351 |
|
requisito_msg = nodo_requi_efe._attrs.get('msg').value.encode('ISO-8859-1') |
352 |
|
except: |
353 |
|
requisito_msg = 'No tienes suficiente ' + requisito_atrib |
354 |
|
uso_requisitos.append( {"atributo":requisito_atrib, |
355 |
|
"valor":requisito_valor, |
356 |
|
"msg":requisito_msg} ) |
357 |
|
|
358 |
|
else: |
359 |
|
|
360 |
|
efecto_atrib = nodo_requi_efe._attrs.get('atributo').value.encode('ISO-8859-1') |
361 |
|
efecto_valor = int(nodo_requi_efe._attrs.get('valor').value.encode('ISO-8859-1')) |
362 |
|
try: |
363 |
|
efecto_msg = nodo_requi_efe._attrs.get('msg').value.encode('ISO-8859-1') |
364 |
|
except: |
365 |
|
efecto_msg = "" |
366 |
|
uso_efectos.append( {"atributo":efecto_atrib, |
367 |
|
"valor":efecto_valor, |
368 |
|
"msg":efecto_msg} ) |
369 |
|
|
370 |
|
self.__usos.append( {"tipo":uso_tipo, |
371 |
|
"posicion":uso_posicion, |
372 |
|
"gasto":uso_gasto, |
373 |
|
"msg":uso_msg, |
374 |
|
"duracion":uso_duracion, |
375 |
|
"requisitos":uso_requisitos, |
376 |
|
"efectos":uso_efectos} ) |
377 |
|
|
378 |
|
|
379 |
|
def activar(self): |
380 |
|
"""Realiza algunos chequeos periodicos de integridad del objeto. |
381 |
|
Los chequeos se pueden hacer, por ejemplo, al coger el objeto. |
382 |
|
""" |
383 |
|
archivo = os.path.join(Objeto.DIR_DESC_OBJETOS, self.__id + Objeto.EXT_DESC_OBJETOS) |
384 |
|
if self.__fecha_fichero < os.path.getmtime(archivo): |
385 |
|
# Si se modifica el fichero descriptor, recargarlo de nuevo |
386 |
|
# reseteando completamente el objeto |
387 |
|
escribir("Recargando objeto " + self.__id + " desde el fichero de descripcion") |
388 |
|
self.__inicializar_objeto() |
389 |
|
|
390 |
|
|
391 |
|
def __setstate__(self, atributos): |
392 |
|
"""Método llamado para restaurar los atributos provinientes de un pickle.""" |
393 |
|
|
394 |
|
self.__dict__ = atributos |
395 |
|
|
396 |
|
# Verificar la versión. |
397 |
|
if not self.__dict__.has_key("_Objeto__version"): |
398 |
|
escribir("Cargado objeto " + self.id + " obsoleto: sin versión," + |
399 |
|
" cuando se esperaba " + Objeto.VERSION_OBJETO + ". Reseteando objeto.") |
400 |
|
if atributos.has_key('id'): |
401 |
|
self.__dict__ = {'_Objeto__id':atributos['id']} |
402 |
|
else: |
403 |
|
self.__dict__ = {'_Objeto__id':atributos['_Objeto__id']} |
404 |
|
self.__inicializar_objeto() |
405 |
|
|
406 |
|
assert(Objeto.VERSION_OBJETO == "1.0") |
407 |
|
|
408 |
|
if self.__version != "1.0": |
409 |
|
escribir("Cargado objeto " + self.__id + " con versión desconocida: " + |
410 |
|
self.__version + ", cuando se esperaba " + Objeto.VERSION_OBJETO + |
411 |
|
". Reseteando objeto.") |
412 |
|
if atributos.has_key('id'): |
413 |
|
self.__dict__ = {'_Objeto__id':atributos['id']} |
414 |
|
else: |
415 |
|
self.__dict__ = {'_Objeto__id':atributos['_Objeto__id']} |
416 |
|
self.__inicializar_objeto() |
417 |
|
|
418 |
|
|
|
def salvar(self): |
|
|
"""Graba en un fichero de DIR_OBJETOS el objeto con todo su contenido.""" |
|
|
|
|
|
fichero = open(os.path.join(Objeto.DIR_OBJETOS, self.id), 'w') |
|
|
cPickle.dump(self, fichero) |
|
|
fichero.close() |
|
|
|
|
|
print "TRAZA: hemos dumpeado con pickle el fichero",self.id |
|
|
|
|
419 |
|
|
|
# Métodos que se refieren a la clase pero tienen ámbito de clase, |
|
|
# y no de instancia |
|
|
|
|
|
|
|
|
def Objeto_cargar(archivo): |
|
|
fichero = open(os.path.join(Objeto.DIR_OBJETOS, archivo), "r") |
|
|
objeto = cPickle.load(fichero) |
|
|
fichero.close() |
|
|
|
|
|
return objeto |
|
|
|
|
|
|
|
420 |
# Código para pruebas unitarias del módulo. |
# Código para pruebas unitarias del módulo. |
421 |
|
|
422 |
if (__name__ == '__main__'): |
if (__name__ == '__main__'): |