22 |
|
|
23 |
"""Clase Personaje.""" |
"""Clase Personaje.""" |
24 |
|
|
25 |
from random import choice |
from random import choice, random |
26 |
from math import floor |
from math import floor |
27 |
from utils import * |
from utils import * |
28 |
from string import * |
from string import * |
47 |
|
|
48 |
# Versión del sistema de personajes (se incrementa al cambiar cualquiera |
# Versión del sistema de personajes (se incrementa al cambiar cualquiera |
49 |
# de Personaje, PersonajeJugador o PersonajeNoJugador) |
# de Personaje, PersonajeJugador o PersonajeNoJugador) |
50 |
VERSION = '1.5.5' |
VERSION = '1.5.6' |
51 |
|
|
52 |
# Resultados de comparar otro personaje con este |
# Resultados de comparar otro personaje con este |
53 |
COMP_INF_MAS_FUERTE = 9 |
COMP_INF_MAS_FUERTE = 9 |
71 |
'mano-der', 'dos-manos', 'piernas', 'tobillo-izq', 'tobillo-der', |
'mano-der', 'dos-manos', 'piernas', 'tobillo-izq', 'tobillo-der', |
72 |
'pie-izq', 'pie-der' ] |
'pie-izq', 'pie-der' ] |
73 |
|
|
74 |
|
# Dinero que porta un personaje nuevo si no se indica otra cosa |
75 |
|
DINERO_INICIAL = 1000 |
76 |
|
|
77 |
|
|
78 |
# Atributos públicos de la clase |
# Atributos públicos de la clase |
79 |
|
|
80 |
def __leer_id(self): return self.__id |
def __leer_id(self): return self.__id |
335 |
salas_visitadas != None |
salas_visitadas != None |
336 |
""") |
""") |
337 |
|
|
338 |
|
|
339 |
|
def __leer_dinero(self): return self.__dinero |
340 |
|
|
341 |
|
dinero = property(__leer_dinero, |
342 |
|
doc="""(int): Cantidad de monedas que lleva encima el personaje. |
343 |
|
|
344 |
|
Invariantes: |
345 |
|
dinero >= 0 |
346 |
|
""") |
347 |
|
|
348 |
|
|
349 |
# Constructor |
# Constructor |
350 |
|
|
351 |
def __init__(self, id, sala, nombre, descripcion, experiencia, nivel, vida, |
def __init__(self, id, sala, nombre, descripcion, experiencia, nivel, vida, |
352 |
volumen, estado, aura, controlador, atrib, idiomas, idioma_base): |
volumen, estado, aura, controlador, atrib, idiomas, idioma_base, |
353 |
|
dinero): |
354 |
"""Método para crear una nueva instancia de esta clase. |
"""Método para crear una nueva instancia de esta clase. |
355 |
|
|
356 |
Personaje es una clase abstracta, luego no puede ser directamente |
Personaje es una clase abstracta, luego no puede ser directamente |
366 |
# __tiradas ({string:int}): nombres y resultados de las tiradas realizadas por este personaje |
# __tiradas ({string:int}): nombres y resultados de las tiradas realizadas por este personaje |
367 |
# __competiciones ({string:int}): nombres y resultados de las competiciones realizadas por este |
# __competiciones ({string:int}): nombres y resultados de las competiciones realizadas por este |
368 |
# personaje |
# personaje |
369 |
|
# __tasaciones ({string:(int, int, FechaHoraMine)}): tasaciones de objetos realizadas. |
370 |
|
# La clave es el id de un objeto, que apunta a una tupla (valor, beneficio, fecha) |
371 |
|
|
372 |
self.__id = id |
self.__id = id |
373 |
self.__version = Personaje.VERSION |
self.__version = Personaje.VERSION |
386 |
self.__atrib = atrib |
self.__atrib = atrib |
387 |
self.__idiomas = idiomas |
self.__idiomas = idiomas |
388 |
self.__idioma_base = idioma_base |
self.__idioma_base = idioma_base |
389 |
|
self.__dinero = dinero |
390 |
|
|
391 |
self.__siguiente = None |
self.__siguiente = None |
392 |
self.__anterior = None |
self.__anterior = None |
393 |
|
|
394 |
self.__tiradas = {} |
self.__tiradas = {} |
395 |
self.__competiciones = {} |
self.__competiciones = {} |
396 |
|
self.__tasaciones = {} |
397 |
|
|
398 |
from objeto import Objeto |
from objeto import Objeto |
399 |
|
|
474 |
raise ValueError("Cargado personaje " + self.__id + " obsoleto: sin versión" + |
raise ValueError("Cargado personaje " + self.__id + " obsoleto: sin versión" + |
475 |
" cuando se esperaba " + Personaje.VERSION) |
" cuando se esperaba " + Personaje.VERSION) |
476 |
|
|
477 |
assert(Personaje.VERSION == "1.5.5") |
assert(Personaje.VERSION == "1.5.6") |
478 |
while self.__version != "1.5.5": |
while self.__version != "1.5.6": |
479 |
|
|
480 |
# La versión 1.5.1 produce una ruptura con las anteriores ya que se migra al formato |
# La versión 1.5.1 produce una ruptura con las anteriores ya que se migra al formato |
481 |
# de clases de Python 2.2, y no es compatible con el anterior. Hay que borrar todas |
# de clases de Python 2.2, y no es compatible con el anterior. Hay que borrar todas |
511 |
item["personaje_mira"] = None |
item["personaje_mira"] = None |
512 |
self.__version = "1.5.5" |
self.__version = "1.5.5" |
513 |
escribir("Convertido personaje " + self.__id + " a versión 1.5.5") |
escribir("Convertido personaje " + self.__id + " a versión 1.5.5") |
514 |
|
if self.__version == "1.5.5": |
515 |
|
# Versión 1.5.5 -> 1.5.6: añadir __dinero y __tasaciones |
516 |
|
self.__dinero = Personaje.DINERO_INICIAL |
517 |
|
self.__tasaciones = {} |
518 |
|
self.__version = "1.5.6" |
519 |
|
escribir("Convertido personaje " + self.__id + " a versión 1.5.6") |
520 |
else: |
else: |
521 |
raise ValueError("Cargado personaje " + self.__id + " con versión desconocida: " + |
raise ValueError("Cargado personaje " + self.__id + " con versión desconocida: " + |
522 |
self.__version + " cuando se esperaba " + Personaje.VERSION) |
self.__version + " cuando se esperaba " + Personaje.VERSION) |
620 |
#%% OJO, comprobar los máximos... |
#%% OJO, comprobar los máximos... |
621 |
|
|
622 |
|
|
623 |
|
def cambiar_dinero(self, monedas): |
624 |
|
"""Modifica el valor de la propiedad dinero, sumando las monedas indicadas. |
625 |
|
|
626 |
|
Si el resultado es menor que cero, se trunca. |
627 |
|
""" |
628 |
|
self.__dinero += monedas |
629 |
|
if self.__dinero < 0: |
630 |
|
self.__dinero = 0 |
631 |
|
|
632 |
|
|
633 |
|
def pagar(self, otro_personaje, monedas): |
634 |
|
"""Transfiere una cantidad de dinero a otro personaje.""" |
635 |
|
self.cambiar_dinero(-monedas) |
636 |
|
otro_personaje.cambiar_dinero(monedas) |
637 |
|
if otro_personaje.controlador != None: |
638 |
|
otro_personaje.controlador.paga_personaje(self, monedas) |
639 |
|
|
640 |
|
|
641 |
def volumen_total(self): |
def volumen_total(self): |
642 |
"""El total de volumen que ocupa el personaje y todos los objetos que carga. |
"""El total de volumen que ocupa el personaje y todos los objetos que carga. |
643 |
Asegura: |
Asegura: |
680 |
|
|
681 |
Se olvidan todas las tiradas y competiciones memorizadas. |
Se olvidan todas las tiradas y competiciones memorizadas. |
682 |
|
|
683 |
|
Se comprueba si lleva algún objeto propiedad de otro, y se toman en su caso |
684 |
|
las acciones correspondientes. |
685 |
|
|
686 |
El parametro automatico es solo para uso interno. |
El parametro automatico es solo para uso interno. |
687 |
|
|
688 |
Requiere: |
Requiere: |
694 |
""" |
""" |
695 |
try: |
try: |
696 |
|
|
697 |
|
from mundo import Mundo |
698 |
|
if self.__sala.id != Mundo.ID_SALA_LIMBO and \ |
699 |
|
sala_destino.id != Mundo.ID_SALA_LIMBO: |
700 |
|
objeto_ajeno = self.buscar_objeto_ajeno() |
701 |
|
if objeto_ajeno != None: |
702 |
|
raise ExcepcionDeJuego("No puedes salir llevando " + objeto_ajeno.nombre + |
703 |
|
". No es de tu propiedad") |
704 |
|
|
705 |
if not automatico: |
if not automatico: |
706 |
if self.__anterior != None: |
if self.__anterior != None: |
707 |
self.no_seguir(); |
self.no_seguir(); |
735 |
self.__competiciones = {} |
self.__competiciones = {} |
736 |
|
|
737 |
except: |
except: |
|
escribir("Excepción imprevista durante el movimiento de un personaje.") |
|
|
escribir_excepcion() |
|
738 |
|
|
739 |
# Si hay algún error en los avisos, intentamos mover el pesonaje |
# Si hay algún error en los avisos, intentamos mover el pesonaje |
740 |
# a un estado consistente (cumpliendo todas las invariantes) |
# a un estado consistente (cumpliendo todas las invariantes) |
1259 |
return result |
return result |
1260 |
|
|
1261 |
|
|
1262 |
|
def tasar_objeto(self, objeto): |
1263 |
|
"""Devuelve el valor que este personaje atribuye al objeto. |
1264 |
|
|
1265 |
|
La fórmula parte del valor base del objeto, y puede añadir modificadores |
1266 |
|
basados en: |
1267 |
|
- la sala donde se encuentran (que puede tener tablas de modificadores |
1268 |
|
por tipo de objeto) |
1269 |
|
- un modificador aleatorio por el humor del personaje en el día :) |
1270 |
|
|
1271 |
|
También calcula un beneficio que el personaje espera obtener si lo |
1272 |
|
compra y luego lo vende. |
1273 |
|
|
1274 |
|
El valor tasado y el beneficio se recuerdan durante todo un día, para |
1275 |
|
evitar obtener precios diferentes al preguntar varias veces seguidas. |
1276 |
|
""" |
1277 |
|
ahora = FechaHoraMine_ahora() |
1278 |
|
|
1279 |
|
# Primero limpiamos la lista de tasaciones antiguas |
1280 |
|
for id in self.__tasaciones: |
1281 |
|
(valor, beneficio, fecha) = self.__tasaciones[id] |
1282 |
|
if fecha.anno() != ahora.anno() or \ |
1283 |
|
fecha.mes() != ahora.mes() or \ |
1284 |
|
fecha.dia() != ahora.dia(): |
1285 |
|
del self.__tasaciones[id] |
1286 |
|
|
1287 |
|
# Comprobamos si ya se ha "tasado" este objeto hoy. Si no, pues |
1288 |
|
# aplicamos la fórmula. |
1289 |
|
if self.__tasaciones.has_key(objeto.id): |
1290 |
|
|
1291 |
|
(valor, beneficio, fecha) = self.__tasaciones[objeto.id] |
1292 |
|
|
1293 |
|
else: |
1294 |
|
|
1295 |
|
valor = objeto.valor |
1296 |
|
|
1297 |
|
#%% De momento no se hace lo del modificador por tipo de objeto... |
1298 |
|
|
1299 |
|
# Modificador aleatorio de + - 10% |
1300 |
|
valor = valor * (random() * 0.2 + 0.9) |
1301 |
|
|
1302 |
|
# Beneficio aleatorio de entre un 10% y un 30% |
1303 |
|
beneficio = random() * 0.2 + 0.1 |
1304 |
|
|
1305 |
|
valor = int(round(valor)) |
1306 |
|
beneficio = int(round(beneficio)) |
1307 |
|
self.__tasaciones[objeto.id] = (valor, beneficio, ahora) |
1308 |
|
|
1309 |
|
return (valor, beneficio) |
1310 |
|
|
1311 |
|
|
1312 |
|
def precio_compra_objeto(self, objeto, vendedor): |
1313 |
|
"""Devuelve el precio al que este personaje está dispuesto a comprar |
1314 |
|
ese objeto a ese vendedor. |
1315 |
|
|
1316 |
|
La fórmula parte del valor tasado del objeto, y puede añadir modificadores |
1317 |
|
basados en: |
1318 |
|
- el carisma del personaje vendedor |
1319 |
|
- la relación de confianza entre ambos |
1320 |
|
- un descuento por beneficio |
1321 |
|
""" |
1322 |
|
(precio, beneficio) = self.tasar_objeto(objeto) |
1323 |
|
|
1324 |
|
# Si el vendedor gana una competición de carisma contra la inteligencia |
1325 |
|
# de este, consigue un precio de compra 10% mayor. |
1326 |
|
if not self.competicion(vendedor, "inteligencia", "carisma"): |
1327 |
|
precio = precio * 1.1 |
1328 |
|
|
1329 |
|
#%% de momento, no hay fórmula de confianza |
1330 |
|
|
1331 |
|
# Al comprar, le reducimos la mitad del beneficio (al vender le sumaremos |
1332 |
|
# la otra mitad). |
1333 |
|
precio = precio - (beneficio / 2) |
1334 |
|
|
1335 |
|
return int(round(precio)) |
1336 |
|
|
1337 |
|
|
1338 |
|
def precio_venta_objeto(self, objeto, comprador): |
1339 |
|
"""Devuelve el precio al que este personaje está dispuesto a vender |
1340 |
|
ese objeto a ese comprador. |
1341 |
|
|
1342 |
|
La fórmula es equivalente a la de compra, cambiando de signo los |
1343 |
|
modificadores. |
1344 |
|
""" |
1345 |
|
(precio, beneficio) = self.tasar_objeto(objeto) |
1346 |
|
|
1347 |
|
# Si el comprador gana una competición de carisma contra la inteligencia |
1348 |
|
# de este, consigue un precio de venta 10% menor. |
1349 |
|
if not self.competicion(comprador, "inteligencia", "carisma"): |
1350 |
|
precio = precio * 0.9 |
1351 |
|
|
1352 |
|
#%% de momento, no hay fórmula de confianza |
1353 |
|
|
1354 |
|
# Al vender, le sumamos la mitad del beneficio (al comprar le restamos |
1355 |
|
# la otra mitad). |
1356 |
|
precio = precio + (beneficio / 2) |
1357 |
|
|
1358 |
|
return int(round(precio)) |
1359 |
|
|
1360 |
|
|
1361 |
def mirar_objeto(self, objeto): |
def mirar_objeto(self, objeto): |
1362 |
"""Examina la descripción de un objeto, y ejecuta todos los guiones asociados. |
"""Examina la descripción de un objeto, y ejecuta todos los guiones asociados. |
1363 |
|
|
1413 |
Lanza ExcepcionDeJuego si no se puede coger (el id no existe, se piden mas |
Lanza ExcepcionDeJuego si no se puede coger (el id no existe, se piden mas |
1414 |
instancias de las que hay, etc.) |
instancias de las que hay, etc.) |
1415 |
|
|
1416 |
|
Si una o más instancias del objeto pertenece a un personaje distinto, |
1417 |
|
toma las acciones correspondientes. |
1418 |
|
|
1419 |
Requiere: |
Requiere: |
1420 |
id_objeto != None |
id_objeto != None |
1421 |
n_orden >= 1 |
n_orden >= 1 |
1433 |
#%% aquí habría que hacer una tirada en algún sitio... |
#%% aquí habría que hacer una tirada en algún sitio... |
1434 |
self.actuar("ha cogido " + objetos[0].nombre) |
self.actuar("ha cogido " + objetos[0].nombre) |
1435 |
|
|
1436 |
|
for objeto in objetos: |
1437 |
|
if objeto.propietario != None and \ |
1438 |
|
objeto.propietario != self.__id.split("%")[0]: |
1439 |
|
|
1440 |
|
#%%PROVISIONAL: aquí lo que hay que hacer en realidad |
1441 |
|
#es lanzar un suceso sobre el propietario |
1442 |
|
if self.__controlador != None: |
1443 |
|
self.__controlador.suceso_entorno("Este objeto es propiedad de " + |
1444 |
|
objeto.propietario + ".") |
1445 |
|
|
1446 |
|
for id in self.__sala.personajes: |
1447 |
|
personaje = self.__sala.personajes[id] |
1448 |
|
if personaje.id.split("%")[0] == objeto.propietario: |
1449 |
|
self.__controlador.suceso_entorno( |
1450 |
|
"Su valor es de " + |
1451 |
|
str(personaje.precio_venta_objeto(objeto, self)) + |
1452 |
|
" monedas.") |
1453 |
|
|
1454 |
return objetos[0].nombre |
return objetos[0].nombre |
1455 |
|
|
1456 |
|
|
1500 |
Genera un suceso de actuar, salvo si se indica con sigilo, y otro de actuar |
Genera un suceso de actuar, salvo si se indica con sigilo, y otro de actuar |
1501 |
individual. |
individual. |
1502 |
|
|
1503 |
|
Si el objeto es propiedad del que lo lleva, el propietario desaparece. Si |
1504 |
|
es propiedad de un tercero, no se puede dar. |
1505 |
|
|
1506 |
- receptor es el personaje que recibe el objeto |
- receptor es el personaje que recibe el objeto |
1507 |
|
|
1508 |
Resto de información del método igual que coger(). |
Resto de información del método igual que coger(). |
1509 |
""" |
""" |
1510 |
# Comprobar que el personaje que da el objeto se encuentra en la lista |
# Comprobar que el personaje que da el objeto se encuentra en la lista |
1511 |
# de confianza del receptor (salvo que el que da sea un Maia...), y que |
# de confianza del receptor (salvo que el que da sea un Maia...), y que |
1512 |
# la confianza es >= 0. |
# la confianza es >= 0. |
1513 |
if not self.__es_maia: |
if not self.__es_maia: |
1514 |
try: |
try: |
1515 |
confianza = receptor.ids_amigos[self.__id] |
confianza = receptor.ids_amigos[self.__id] |
1516 |
if confianza < 1: |
if confianza < 1: |
1517 |
raise KeyError |
raise KeyError |
1518 |
except KeyError, e: |
except KeyError, e: |
1519 |
self.actuar_individual(receptor, "te ha intentado dar " + id_objeto + " pero te has negado.") |
self.actuar_individual(receptor, "te ha intentado dar " + id_objeto + " pero te has negado.") |
1520 |
raise ExcepcionDeJuego(receptor.nombre + " no acepta tu objeto.") |
raise ExcepcionDeJuego(receptor.nombre + " no acepta tu objeto.") |
1521 |
|
|
1522 |
n_objeto = self.buscar_en_mochila(id_objeto, n_orden) |
n_objeto = self.buscar_en_mochila(id_objeto, n_orden) |
1523 |
objetos = self.sacar_de_mochila(n_objeto, n_instancia, cantidad) |
objetos = self.sacar_de_mochila(n_objeto, n_instancia, cantidad) |
|
receptor.meter_en_mochila(objetos) |
|
1524 |
|
|
1525 |
if not sigilo: |
# Ver si alguno de los objetos tiene dueño |
1526 |
#%% aquí habría que hacer una tirada en algún sitio... |
for objeto in objetos: |
1527 |
self.__personaje.actuar("ha dado " + objetos[0].nombre + " a " + receptor.nombre) |
if objeto.propietario != None: |
1528 |
|
if objeto.propietario == self.__id.split("%")[0]: |
1529 |
|
objeto.cambiar_propietario(None) |
1530 |
|
else: |
1531 |
|
self.meter_en_mochila(objetos) |
1532 |
|
raise ExcepcionDeJuego("No puedes dar " + objeto.nombre + |
1533 |
|
". No es de tu propiedad.") |
1534 |
|
|
1535 |
|
receptor.meter_en_mochila(objetos) |
1536 |
|
|
1537 |
|
if not sigilo: |
1538 |
|
#%% aquí habría que hacer una tirada en algún sitio... |
1539 |
|
self.__personaje.actuar("ha dado " + objetos[0].nombre + " a " + receptor.nombre) |
1540 |
|
|
1541 |
|
msg = "te ha dado " + objetos[0].nombre |
1542 |
|
if cantidad > 1: |
1543 |
|
msg += ' (' + str(cantidad) + ' unidades)' |
1544 |
|
self.actuar_individual(receptor, msg) |
1545 |
|
|
1546 |
|
return objetos[0].nombre |
1547 |
|
|
1548 |
|
|
1549 |
|
def comprar(self, vendedor, id_objeto, n_orden=1, n_instancia=1, cantidad=1): |
1550 |
|
"""Este personaje compra un objeto a un vendedor. |
1551 |
|
|
1552 |
|
El objeto debe estar ya en posesión del personaje comprador (o sea, éste). |
1553 |
|
Si este personaje tiene suficiente dinero, se le transfiere al vendedor |
1554 |
|
una cantidad igual al precio de venta de ese objeto, y a cambio el vendedor |
1555 |
|
le transfiere la propiedad del objeto. |
1556 |
|
|
1557 |
msg = "te ha dado " + objetos[0].nombre |
- vendedor es el personaje propietario del objeto |
1558 |
if cantidad > 1: |
- id_objeto es el identificador del objeto. Puede haber varios objetos distintos |
1559 |
msg += ' (' + str(cantidad) + ' unidades)' |
con el mismo id |
1560 |
self.actuar_individual(receptor, msg) |
- n_orden sirve para distinguir el objeto si hay mas de uno con el mismo id |
1561 |
|
- n_instancia es para elegir una instancia concreta, si hay mas de una |
1562 |
|
- cantidad es el numero de instancias a extraer |
1563 |
|
|
1564 |
return objetos[0].nombre |
Requiere: |
1565 |
|
vendedor != None |
1566 |
|
id_objeto != None |
1567 |
|
n_orden >= 1 |
1568 |
|
n_instancia >= 1 |
1569 |
|
cantidad >= 1 |
1570 |
|
""" |
1571 |
|
n_objeto = self.buscar_en_mochila(id_objeto, n_orden) |
1572 |
|
instancias = self.__mochila[n_objeto] |
1573 |
|
|
1574 |
|
if (n_instancia + cantidad - 1) > len(instancias): |
1575 |
|
raise ExcepcionDeJuego("No tienes " + str(n_instancia + cantidad - 1) + |
1576 |
|
" unidades de ese objeto en la mochila, solo tienes " + |
1577 |
|
str(len(instancias))) |
1578 |
|
|
1579 |
|
objetos_comprados = [] |
1580 |
|
for i in range(0, cantidad): |
1581 |
|
objetos_comprados.append(instancias[n_instancia-1]) |
1582 |
|
|
1583 |
|
#%%PROVISIONAL: esto deberá hacerse mediante guiones, cuando estén hechos |
1584 |
|
precio = vendedor.precio_venta_objeto(objetos_comprados[0], self) * cantidad |
1585 |
|
if self.dinero < precio: |
1586 |
|
raise ExcepcionDeJuego("No tienes suficiente dinero. " + |
1587 |
|
"El precio son %d monedas y tú sólo tienes %d." & |
1588 |
|
precio, self.dinero) |
1589 |
|
|
1590 |
|
self.pagar(vendedor, precio) |
1591 |
|
for objeto in objetos_comprados: |
1592 |
|
objeto.cambiar_propietario(None) |
1593 |
|
|
1594 |
|
|
1595 |
def comer(self, id_objeto, n_orden=1, n_instancia=1, sigilo=0): |
def comer(self, id_objeto, n_orden=1, n_instancia=1, sigilo=0): |
1621 |
n_objeto = self.buscar_en_mochila(id_objeto, n_orden) |
n_objeto = self.buscar_en_mochila(id_objeto, n_orden) |
1622 |
objeto = self.acceder_a_mochila(n_objeto, n_instancia) |
objeto = self.acceder_a_mochila(n_objeto, n_instancia) |
1623 |
|
|
1624 |
|
if objeto.propietario != None and \ |
1625 |
|
objeto.propietario != self.__id.split("%")[0]: |
1626 |
|
raise ExcepcionDeJuego("No puedes usar este objeto. No es de tu propiedad.") |
1627 |
|
|
1628 |
result = objeto.personaje_come(self) |
result = objeto.personaje_come(self) |
1629 |
if result == 0: |
if result == 0: |
1630 |
raise ExcepcionDeJuego("No puedes comer este objeto.") |
raise ExcepcionDeJuego("No puedes comer este objeto.") |
1644 |
n_objeto = self.buscar_en_mochila(id_objeto, n_orden) |
n_objeto = self.buscar_en_mochila(id_objeto, n_orden) |
1645 |
objeto = self.acceder_a_mochila(n_objeto, n_instancia) |
objeto = self.acceder_a_mochila(n_objeto, n_instancia) |
1646 |
|
|
1647 |
|
if objeto.propietario != None and \ |
1648 |
|
objeto.propietario != self.__id.split("%")[0]: |
1649 |
|
raise ExcepcionDeJuego("No puedes usar este objeto. No es de tu propiedad.") |
1650 |
|
|
1651 |
result = objeto.personaje_bebe(self) |
result = objeto.personaje_bebe(self) |
1652 |
if result == 0: |
if result == 0: |
1653 |
raise ExcepcionDeJuego("No puedes beber este objeto.") |
raise ExcepcionDeJuego("No puedes beber este objeto.") |
1667 |
n_objeto = self.buscar_en_mochila(id_objeto, n_orden) |
n_objeto = self.buscar_en_mochila(id_objeto, n_orden) |
1668 |
objeto = self.acceder_a_mochila(n_objeto, n_instancia) |
objeto = self.acceder_a_mochila(n_objeto, n_instancia) |
1669 |
|
|
1670 |
|
if objeto.propietario != None and \ |
1671 |
|
objeto.propietario != self.__id.split("%")[0]: |
1672 |
|
raise ExcepcionDeJuego("No puedes usar este objeto. No es de tu propiedad.") |
1673 |
|
|
1674 |
result = objeto.personaje_usa(self) |
result = objeto.personaje_usa(self) |
1675 |
if result == 0: |
if result == 0: |
1676 |
raise ExcepcionDeJuego("No puedes usar este objeto.") |
raise ExcepcionDeJuego("No puedes usar este objeto.") |
1693 |
n_objeto = self.buscar_en_mochila(id_objeto, n_orden) |
n_objeto = self.buscar_en_mochila(id_objeto, n_orden) |
1694 |
objeto = self.acceder_a_mochila(n_objeto, n_instancia) |
objeto = self.acceder_a_mochila(n_objeto, n_instancia) |
1695 |
|
|
1696 |
|
if objeto.propietario != None and \ |
1697 |
|
objeto.propietario != self.__id.split("%")[0]: |
1698 |
|
raise ExcepcionDeJuego("No puedes usar este objeto. No es de tu propiedad.") |
1699 |
|
|
1700 |
try: |
try: |
1701 |
n_objeto2 = self.buscar_en_mochila(id_objeto2, n_orden2) |
n_objeto2 = self.buscar_en_mochila(id_objeto2, n_orden2) |
1702 |
objeto2 = self.acceder_a_mochila(n_objeto2, n_instancia2) |
objeto2 = self.acceder_a_mochila(n_objeto2, n_instancia2) |
1933 |
self.cuerpo[posicion] == objeto |
self.cuerpo[posicion] == objeto |
1934 |
return != None |
return != None |
1935 |
""" |
""" |
|
objetos_quitados = self.reservar_posicion(posicion) |
|
|
if len(objetos_quitados) > 0: |
|
|
self.meter_en_mochila(objetos_quitados) |
|
|
|
|
1936 |
n_objeto = self.buscar_en_mochila(id_objeto, n_orden) |
n_objeto = self.buscar_en_mochila(id_objeto, n_orden) |
1937 |
objeto = self.acceder_a_mochila(n_objeto, n_instancia) |
objeto = self.acceder_a_mochila(n_objeto, n_instancia) |
1938 |
|
|
1939 |
|
if objeto.propietario != None and \ |
1940 |
|
objeto.propietario != self.__id.split("%")[0]: |
1941 |
|
raise ExcepcionDeJuego("No puedes usar este objeto. No es de tu propiedad.") |
1942 |
|
|
1943 |
suceso = getattr(objeto, "personaje_pone_" + posicion) |
suceso = getattr(objeto, "personaje_pone_" + posicion) |
1944 |
result = suceso(self) |
result = suceso(self) |
1945 |
if result == 0: |
if result == 0: |
1946 |
raise ExcepcionDeJuego("No te puedes poner este objeto en esa posicion.") |
raise ExcepcionDeJuego("No te puedes poner este objeto en esa posicion.") |
1947 |
else: |
else: |
1948 |
|
objetos_quitados = self.reservar_posicion(posicion) |
1949 |
|
if len(objetos_quitados) > 0: |
1950 |
|
self.meter_en_mochila(objetos_quitados) |
1951 |
|
|
1952 |
objeto = self.sacar_de_mochila(n_objeto, n_instancia, 1)[0] |
objeto = self.sacar_de_mochila(n_objeto, n_instancia, 1)[0] |
1953 |
objeto.contener(self) |
objeto.contener(self) |
1954 |
self.__cuerpo[posicion] = objeto |
self.__cuerpo[posicion] = objeto |
2082 |
self.__cuerpo[parte] = objeto_nuevo |
self.__cuerpo[parte] = objeto_nuevo |
2083 |
|
|
2084 |
|
|
2085 |
|
def buscar_objeto_ajeno(self): |
2086 |
|
"""Busca en la mochila algún objeto propiedad de otro personaje. |
2087 |
|
|
2088 |
|
Devuelve None si no lleva, el objeto en cuestión si lleva uno, o el primero |
2089 |
|
que haya si lleva más de uno. |
2090 |
|
""" |
2091 |
|
for objeto in self.__mochila: |
2092 |
|
instancia = objeto[0] |
2093 |
|
|
2094 |
|
if instancia.propietario != None \ |
2095 |
|
and instancia.propietario != self.__id.split("%")[0]: |
2096 |
|
return instancia |
2097 |
|
|
2098 |
|
return None |
2099 |
|
|
2100 |
|
|
2101 |
def personaje_mira(self, observador, sala): |
def personaje_mira(self, observador, sala): |
2102 |
"""Responde al suceso de que otro personaje mira la descripción de éste. |
"""Responde al suceso de que otro personaje mira la descripción de éste. |
2103 |
|
|