def command_delexit(entity, argument=""):
if not entity:
log.bug("entity non è un parametro valido: %r" % entity)
return False
# -------------------------------------------------------------------------
if not argument:
syntax = get_command_syntax(entity, "command_delexit")
entity.send_output(syntax, break_line=False)
return False
if not entity.location.IS_ROOM:
entity.send_output("Non ti trovi in una stanza ma in %s" % entity.location.code)
return False
room = entity.location
arg1, argument = one_argument(argument)
direction = get_direction(arg1)
if direction == DIR.NONE:
entity.send_output("Direzione non valida ricavata dall'argomento %s" % arg1)
return False
if direction not in room.exits:
entity.send_output("Non c'è nessuna uscita %s da distruggere." % direction.to_dir)
return False
del(room.exits[direction])
entity.send_output("E' stata cancellata l'uscita %s." % direction.to_dir)
return True
def find_entity_from_args(self, arg, argument, quantity=1, location=None, entity_tables=None):
"""
Serve a trovare un'entità nell'inventario di self a seconda degli
argomenti passati.
Se vi è un solo argomento allora prende quello (look target).
Se ve ne sono due allora prende il secondo (look extra target).
Se si passa il parametro location allora viene utilizzata la find_entity
e non la find_entity_extensively.
"""
if not arg:
log.bug("arg non è un parametro valido: %r" % arg)
return None, "", ""
if not argument and argument != "":
log.bug("argument non è un parametro valido: %r" % argument)
return None, "", ""
if quantity < 0:
log.bug("quantity non è un parametro valido: %d" % quantity)
return
# -------------------------------------------------------------------------
if not entity_tables:
entity_tables = self.ENTITY_TABLES
if not argument:
target_argument = arg
extra_argument = ""
else:
target_argument = argument
extra_argument = arg
if is_same(target_argument, ("me", "self")):
target = self
else:
if location:
target = self.find_entity(target_argument, quantity=quantity, location=location, entity_tables=entity_tables)
else:
target = self.find_entity_extensively(target_argument, quantity=quantity, entity_tables=entity_tables)
#global get_direction
#if not get_direction:
# from src.room import get_direction
# Se il target è una porta aperta ricavata tramite una direzione allora
# dà la precedenza all'uscita e non alla porta
if (target and target.door_type and DOOR.CLOSED not in target.door_type.flags
and get_direction(target_argument, exact=False) != DIR.NONE):
return None, target_argument, extra_argument
if quantity == 0:
return target, target_argument, extra_argument
else:
return target.split_entity(quantity) if target else None, target_argument, extra_argument
def dig_an_exit(entity, argument, verbs, behavioured):
if not entity:
log.bug("entity non è un parametro valido: %r" % entity)
return False
if not argument:
log.bug("argument non è un parametro valido: %r" % argument)
return False
if not verbs:
log.bug("verbs non è un parametro valido: %r" % verbs)
return False
# behavioured ha valore di verità
# -------------------------------------------------------------------------
location = entity.location
arg, argument = one_argument(argument)
direction = get_direction(arg)
if direction == DIR.NONE:
entity.act(
"Non trovi nessuna direzione [white]%s[close] in cui %s." %
(arg, verbs["infinitive"]), TO.ENTITY, location)
entity.act(
"$n sembra voler %s in una direzione, ma appare spaesato." %
verbs["infinitive"], TO.OTHERS, location)
entity.act(
"$n sembra voler %s in una direzione, ma appare spaesato." %
verbs["you2"], TO.TARGET, location)
return False
if not location.IS_ROOM:
entity.act(
"Non trovi in un luogo ove poter %s %s." %
(verbs["infinitive"], direction.to_dir), TO.ENTITY, location)
entity.act(
"$n sembra voler %s %s nonostante non si trovi in un luogo con delle uscite."
% (verbs["infinitive"], direction.to_dir), TO.OTHERS, location)
entity.act(
"Non sei un luogo in cui si possa %s %s, eppure $n ci sta provando lo stesso."
% (verbs["infinitive"], direction.to_dir), TO.TARGET, location)
return False
# (TD) Questo si potrebbe convertire in metodo se dovesse servire nuovamente
exit = None
has_secret_door = False
if direction in location.exits:
exit = location.exits[direction]
door = location.get_door(direction)
if door and door.door_type and DOOR.SECRET in door.door_type.flags and DOOR.CLOSED in door.door_type.flags:
has_secret_door = True
if exit and EXIT.DIGGABLE not in exit.flags and not has_secret_door:
entity.act(
"Non sapresti proprio come %s %s: c'è già un'uscita!" %
(verbs["infinitive"], direction.to_dir), TO.ENTITY, location)
entity.act(
"$n sembra voler %s %s: ma c'è già un'uscita!" %
(verbs["infinitive"], direction.to_dir), TO.OTHERS, location)
entity.act(
"$n sembra voler %s %s: ma li hai già un'uscita!" %
(verbs["infinitive"], direction.to_dir), TO.TARGET, location)
return False
entity.act("Cominci a %s %s." % (verbs["infinitive"], direction.to_dir),
TO.ENTITY, location)
entity.act(
"$n comincia a %s %s." % (verbs["infinitive"], direction.to_dir),
TO.OTHERS, location)
entity.act("$n comincia a %s %s." % (verbs["you2"], direction.to_dir),
TO.TARGET, location)
force_return = check_trigger(entity, "before_dig", entity, location, exit,
direction, behavioured)
if force_return:
return True
force_return = check_trigger(location, "before_digged", entity, location,
exit, direction, behavioured)
if force_return:
return True
# (TD) Togliere un po' di energie nella scavata
if exit and not has_secret_door:
defer_later_function = digging_a_diggable_exit_1
else:
defer_later_function = digging_an_inexistent_exit_1
entity.action_in_progress = ActionInProgress(DIG_SECONDS,
defer_later_function,
stop_digging_on_exit, entity,
location, direction, verbs,
behavioured)
return True
def give_or_put(entity, argument, verbs, behavioured, entity_tables, noflag,
noroom, gamescript_suffix1, gamescript_suffix2,
gamescript_suffix3, preposition):
if not entity:
log.bug("entity non è un parametro valido: %r" % entity)
return False
# argument può essere una stringa vuota
if not verbs:
log.bug("verbs non è un parametro valido: %r" % verbs)
return False
if not entity_tables:
log.bug("entity_tables non è un parametro valido: %r" % entity_tables)
return False
if noflag not in (FLAG.NO_PUT, FLAG.NO_GIVE):
log.bug("noflag non è un parametro valido: %r" % noflag)
return False
if noroom not in (ROOM.NO_PUT, ROOM.NO_GIVE):
log.bug("noroom non è un parametro valido: %r" % noroom)
return False
if gamescript_suffix1 not in ("put", "give"):
log.bug("gamescript_suffix1 non è un parametro valido: %r" %
gamescript_suffix1)
return False
if gamescript_suffix2 not in ("putted", "gave"):
log.bug("gamescript_suffix2 non è un parametro valido: %r" %
gamescript_suffix2)
return False
if gamescript_suffix3 not in ("putting", "giving"):
log.bug("gamescript_suffix3 non è un parametro valido: %r" %
gamescript_suffix3)
return False
if preposition not in ("in", "a"):
log.bug("gamescript_suffix non è un parametro valido: %r" %
gamescript_suffix)
return False
# -------------------------------------------------------------------------
entity = entity.split_entity(1)
if not argument:
entity.send_output(
"Che [white]cosa[close] vorresti %s %s [white]%s[close]?" %
(verbs["infinitive"], preposition,
"qualcuno" if preposition == "a" else "qualcosa"))
if entity.IS_PLAYER and OPTION.NEWBIE in entity.account.options:
syntax = get_command_syntax(entity, "command_put")
entity.send_output(syntax)
return False
# Ricava l'eventuale quantità d'oggetti da posare
quantity, argument = quantity_argument(argument)
arg1, argument = one_argument(argument)
# (TD) Controllo del mental state deviato
# Ricerca nell'inventario dell'entità quella da dare o mettere
target = entity.find_entity(arg1, quantity=quantity, location=entity)
arg2 = ""
receiver = None
if argument:
arg2, argument = one_argument(argument)
# Rimuove eventuali argomenti facoltativi
if argument and arg2 == "a":
arg2, argument = one_argument(argument)
# Ricerca dell'entità bersaglio a cui dare l'entità target
receiver = entity.find_entity_extensively(arg2,
entity_tables=entity_tables)
# Controlla se si vuole inserire una porta sui cardini di un'uscita
direction = get_direction(arg2)
if target and not receiver and direction != DIR.NONE:
if not entity.location.IS_ROOM:
entity.act(
"Vorresti %s $N sui cardini di un'eventuale uscita %s, ma non ti trovi in una stanza."
% (verbs["infinitive"], direction.to_dir), TO.ENTITY,
target)
entity.act(
"$n vorrebbe %s $N sui cardini di un'eventuale uscita %s, ma non vi trovate in una stanza."
% (verbs["infinitive"], direction.to_dir), TO.OTHERS,
target)
entity.act(
"$n ti vorrebbe %s sui cardini di un'eventuale uscita %s, ma non vi trovate in una stanza."
% (verbs["infinitive"], direction.to_dir), TO.TARGET,
target)
return False
if not direction in entity.location.exits:
entity.act(
"Vorresti %s $N sui cardini di un'eventuale uscita %s, ma questa non esiste."
% (verbs["infinitive"], direction.to_dir), TO.ENTITY,
target)
entity.act(
"$n vorrebbe %s $N sui cardini di un'eventuale uscita %s, ma questa non esiste."
% (verbs["infinitive"], direction.to_dir), TO.OTHERS,
target)
entity.act(
"$n ti vorrebbe %s sui cardini di un'eventuale uscita %s, ma questa non esiste."
% (verbs["infinitive"], direction.to_dir), TO.TARGET,
target)
return False
exit_door = entity.location.exits[direction].door
if exit_door:
entity.act(
"Vorresti %s $N sui cardini dell'uscita %s, ma questa possiede già $a."
% (verbs["infinitive"], direction.to_dir), TO.ENTITY,
target, exit_door)
entity.act(
"$n vorrebbe %s $N sui cardini dell'uscita %s, ma questa possiede già $a."
% (verbs["infinitive"], direction.to_dir), TO.OTHERS,
target, exit_door)
entity.act(
"$n ti vorrebbe %s sui cardini dell'uscita %s, ma questa possiede già $a."
% (verbs["infinitive"], direction.to_dir), TO.TARGET,
target, exit_door)
return False
if not target.door_type:
entity.act(
"Vorresti %s sui cardini dell'uscita %s $N, ma quest'ultim$O non è una porta."
% (verbs["infinitive"], direction.to_dir), TO.ENTITY,
target, exit_door)
entity.act(
"$n vorrebbe %s sui cardini dell'uscita %s $N, ma quest'ultim$O non è una porta."
% (verbs["infinitive"], direction.to_dir), TO.OTHERS,
target, exit_door)
entity.act(
"$n ti vorrebbe %s sui cardini dell'uscita %s, ma non sei una porta."
% (verbs["infinitive"], direction.to_dir), TO.TARGET,
target, exit_door)
return False
if quantity > 1:
entity.act(
"Vorresti %s sui cardini dell'uscita %s $N, ma è possibile inserirne solo un$O."
% (verbs["infinitive"], direction.to_dir), TO.ENTITY,
target, exit_door)
entity.act(
"$n vorrebbe %s sui cardini dell'uscita %s $N, ma è possibile inserirne solo un$O"
% (verbs["infinitive"], direction.to_dir), TO.OTHERS,
target, exit_door)
entity.act(
"$n ti vorrebbe %s sui cardini dell'uscita %s, ma è possibile inserirti solo in un'unità."
% (verbs["infinitive"], direction.to_dir), TO.TARGET,
target, exit_door)
return False
force_return = check_trigger(entity,
"before_" + gamescript_suffix1,
entity, target, None, direction,
behavioured)
if force_return:
return True
force_return = check_trigger(target,
"before_" + gamescript_suffix2,
entity, target, None, direction,
behavioured)
if force_return:
return True
force_return = check_trigger(receiver,
"before_" + gamescript_suffix3,
entity, target, None, direction,
behavioured)
if force_return:
return True
entity.act(
"%s $N sui cardini dell'uscita %s." %
(verbs["you"], direction.to_dir), TO.ENTITY, target)
entity.act(
"$n %s $N sui cardini dell'uscita %s." %
(verbs["it"], direction.to_dir), TO.OTHERS, target)
entity.act(
"$n ti %s sui cardini dell'uscita %s." %
(verbs["it"], direction.to_dir), TO.TARGET, target)
target = target.from_location(1)
target.to_location(entity.location)
entity.location.exits[direction].door = target
force_return = check_trigger(entity, "after_" + gamescript_suffix1,
entity, target, None, direction,
behavioured)
if force_return:
return True
force_return = check_trigger(target, "after_" + gamescript_suffix2,
entity, target, None, direction,
behavioured)
if force_return:
return True
force_return = check_trigger(receiver,
"after_" + gamescript_suffix3, entity,
target, None, direction, behavioured)
if force_return:
return True
return True
# -------------------------------------------------------------------------
if not arg2:
arg2 = "qualcuno" if preposition == "a" else "qualcosa"
# Se l'entità a cui dare si trova nell'inventario allora lo indica
on_message_you = ""
on_message_it = ""
if receiver and receiver.location and receiver.location == entity:
if receiver and len(receiver.wear_mode) > 0:
on_message_you = " che stai [khaki]indossando[close]"
on_message_it = " che sta [khaki]indossando[close]"
else:
on_message_you = " nel tuo [yellow]inventario[close]"
on_message_it = " nel suo [yellow]inventario[close]"
# Gestisce le varie combinazioni di entità non trovate e/o uguali
# all'entità che ha digitato il comando
if target:
if not receiver:
entity.act(
"Cerchi di %s $N %s [white]%s[close] che non trovi da nessuna parte."
% (verbs["infinitive"], preposition, arg2), TO.ENTITY, target)
entity.act(
"$n cerca di %s $N %s [white]%s[close] che non sembra trovare da nessuna parte."
% (verbs["infinitive"], preposition, arg2), TO.OTHERS, target)
entity.act(
"$n cerca di %s %s [white]%s[close] che non sembra trovare da nessuna parte."
% (verbs["you2"], preposition, arg2), TO.TARGET, target)
return False
elif receiver == entity:
entity.act(
"Cerchi di %s $N %s te stess$o, ma è già tu$O!" %
(verbs["infinitive"], preposition), TO.ENTITY, target)
entity.act(
"$n cerca di %s $N %s se stess$o, ma è già su$O." %
(verbs["infinitive"], preposition), TO.OTHERS, target)
entity.act(
"$n cerca di %s $N %s se stess$o, ma è già su$O." %
(verbs["infinitive"], preposition), TO.TARGET, target)
return False
elif receiver == target:
entity.act(
"Cerchi di %s $N %s se stess$o, ma ciò è impossibile!" %
(verbs["infinitive"], preposition), TO.ENTITY, target)
entity.act(
"$n cerca di %s $N %s se stess$o, ma ciò è impossibile." %
(verbs["infinitive"], preposition), TO.OTHERS, target)
entity.act(
"$n cerca di %s $N %s te stess$o, ciò è impossibile." %
(verbs["infinitive"], preposition), TO.TARGET, target)
return False
elif not target:
if not receiver:
entity.act(
"Cerchi di %s [white]%s[close] %s [white]%s[close], ma non trovi nulla e nessuno nel tuo inventario."
% (verbs["infinitive"], arg1, preposition, arg2), TO.ENTITY)
entity.act(
"$n cerca di %s [white]qualcosa[close] %s [white]quacuno[close], ma senza molti risultati nel suo inventario."
% (verbs["infinitive"], preposition), TO.OTHERS)
return False
elif receiver == entity:
if entity.IS_ITEM:
entity.act(
"Cerchi di [orange]passarti [white]%s[close], ma non trovi [gray]nulla del genere[close] nel tuo [yellow]inventario[close]."
% arg1, TO.ENTITY, receiver)
entity.act(
"$n cerca di [orange]passarsi [white]qualcosa[close] che [gray]non sembra trovare[close] nel suo [yellow]inventario[close].",
TO.OTHERS, receiver)
else:
entity.act(
"Cerchi di [orange]passarti[close] da una $hand all'altra [white]%s[close], ma non trovi [gray]nulla del genere[close] nel tuo [yellow]inventario[close]."
% arg1, TO.ENTITY, receiver)
entity.act(
"$n cerca di [orange]passarsi[close] da una $hand all'altra [white]qualcosa[close] che [gray]non sembra trovare[close] nel suo [yellow]inventario[close].",
TO.OTHERS, receiver)
return False
else:
if on_message_you and on_message_it:
entity.act(
"Cerchi di %s un [white]%s[close] %s $N%s, ma non trovi [gray]nulla del genere[close]."
% (verbs["infinitive"], arg1, preposition, on_message_you),
TO.ENTITY, receiver)
entity.act(
"$n cerca di %s [white]qualcosa[close] %s $N%s, ma non sembra trovare [gray]nulla del genere[close]."
% (verbs["infinitive"], preposition, on_message_it),
TO.OTHERS, receiver)
entity.act(
"$n cerca di %s [white]qualcosa[close], ma non sembra trovare [gray]nulla del genere[close]."
% (verbs["infinitive"]), TO.TARGET, receiver)
else:
entity.act(
"Cerchi di %s un [white]%s[close] %s $N, ma non trovi [gray]nulla del genere[close] nel tuo [yellow]inventario[close]."
% (verbs["infinitive"], arg1, preposition), TO.ENTITY,
receiver)
entity.act(
"$n cerca di %s [white]qualcosa[close] %s $N, ma non sembra trovare [gray]nulla del genere[close] nel suo [yellow]inventario[close]."
% (verbs["infinitive"], preposition[2:]), TO.OTHERS,
receiver)
entity.act(
"$n cerca di %s [white]qualcosa[close], ma non sembra trovare [gray]nulla del genere[close] nel suo [yellow]inventario[close]."
% (verbs["infinitive"]), TO.TARGET, receiver)
return False
if quantity == 0:
quantity = target.quantity
elif target.quantity < quantity:
entity.act(
"Non puoi %s $N perché ne possiedi solo %d e non %d." %
(verbs["infinitive"], target.quantity, quantity), TO.ENTITY,
target)
entity.act(
"$n sta cercando di ammucchiare un quantitativo voluto di $N per poterlo %s"
% verbs["infinitive"], TO.OTHERS, target)
entity.act(
"$n sta cercando di ammucchiarti per un quantitativo voluto per poterti %s"
% verbs["infinitive"], TO.TARGET, target)
return False
if receiver.container_type and CONTAINER.CLOSED in receiver.container_type.flags:
entity.act(
"Cerchi di %s $a %s $N ma l$O trovi chius$O." %
(verbs["infinitive"], preposition), TO.ENTITY, receiver, target)
entity.act(
"$n cerca di %s $a %s $N ma l$O trova chius$O." %
(verbs["infinitive"], preposition), TO.OTHERS, receiver, target)
return False
# Se l'obiettivo a cui dare l'entità è un oggetto e non è un contenitore
# allora solo gli admin possono eseguire l'azione
if receiver.IS_ITEM and not receiver.container_type:
if entity.trust > TRUST.PLAYER:
entity.send_to_admin(
"Il ricevitore non è un contenitore ma tu puoi eseguire comunque l'azione"
)
else:
entity.act(
"Cerchi di %s $N %s $a, ma quest'ultimo non ti sembra un contenitore."
% (verbs["infinitive"], preposition), TO.ENTITY, target,
receiver)
entity.act(
"$n cerca di %s $N %s $a, ma non riesce a trovare modo per farlo non essendo un contenitore."
% (verbs["infinitive"], preposition), TO.OTHERS, target,
receiver)
entity.act(
"$n cerca di %s %s $a, ma non sembra riuscirvi visto che quest'ultimo non è un contenitore."
% (verbs["you2"], preposition), TO.TARGET, target, receiver)
entity.act(
"$n cerca di %s $a, ma avrà ben poca fortuna visto che non sei un contenitore."
% verbs["you"], TO.TARGET, receiver, target)
return False
# Se l'entità che ha inviato il comando ha la noflag viene evitata
# l'azione
if noflag in entity.flags:
if entity.trust > TRUST.PLAYER:
entity.send_to_admin("Tu avresti in realtà la flag NO_GIVE")
else:
entity.act(
"Cerchi di %s $N %s $a, ma qualche [blueroyal]forza misteriosa[close] ti blocca l'azione."
% (verbs["infinitive"], preposition), TO.ENTITY, target,
receiver)
entity.act(
"$n cerca di %s $N %s $a, ma sembra essere bloccat$n da una [royalblue]forza misteriosa[close]."
% (verbs["infinitive"], preposition), TO.OTHERS, target,
receiver)
entity.act(
"$n cerca di %s %s $a, ma sembra essere essere bloccat$o da una [royalblue]forza misteriosa[close]."
% (verbs["you2"], preposition), TO.TARGET, target, receiver)
entity.act(
"$n cerca di %s $a, ma sembre essere bloccat$o da una [royalblue]forza misteriosa[close]."
% verbs["you"], TO.TARGET, receiver, target)
return False
# Se l'oggetto da dare ha la flag NO_GIVE allora evita di farsi
if noflag in target.flags:
if entity.trust > TRUST.PLAYER:
entity.send_to_admin(
"L'entità da dare avrebbe in realtà la flag NO_GIVE")
else:
if entity.IS_ITEM:
entity.act(
"Appena cerchi di %s $N %s $a te lo ritrovi, con un [cyan]balzo[close] addosso."
% (verbs["infinitive"], preposition), TO.ENTITY, target,
receiver)
entity.act(
"Appena $n cerca di %s $N %s $a se lo ritrova, con un [cyan]balzo[close] addosso."
% (verbs["infinitive"], preposition), TO.OTHERS, target,
receiver)
entity.act(
"Appena $n cerca di %s %s $a gli [cyan]rimbalzi[close] addosso."
% (verbs["you2"], preposition), TO.TARGET, target,
receiver)
entity.act(
"Appena $n cerca di %s $a se lo ritrova, con un [cyan]balzo[close] addosso."
% verbs["you2"], TO.TARGET, receiver, target)
else:
entity.act(
"Appena cerchi di %s $N %s $a te lo ritrovi, con un [cyan]balzo[close], in $hand."
% (verbs["infinitive"], preposition), TO.ENTITY, target,
receiver)
entity.act(
"Appena $n cerca di %s $N %s $a se lo ritrova, con un [cyan]balzo[close], in $hand."
% (verbs["infinitive"], preposition), TO.OTHERS, target,
receiver)
entity.act(
"Appena $n cerca di %s %s $a gli [cyan]rimbalzi[close] in $hand."
% (verbs["you2"], preposition), TO.TARGET, target,
receiver)
entity.act(
"Appena $n cerca di %s $a se lo ritrova, con un [cyan]balzo[close], in $hand."
% verbs["you2"], TO.TARGET, receiver, target)
return False
# Se l'entità a cui dare l'oggetto ha la flag NO_GIVE allora non lo accetta
if noflag in receiver.flags:
if entity.trust > TRUST.PLAYER:
entity.send_to_admin(
"L'entità a cui dare avrebbe in realtà la flag NO_GIVE")
else:
if entity.IS_ITEM:
entity.act(
"Cerchi di %s $N %s $a, ma questi te l$O ridà." %
(verbs["infinitive"], preposition), TO.ENTITY, target,
receiver)
entity.act(
"$n cerca di %s $N %s $a, ma questi gliel$O ridà." %
(verbs["infinitive"], preposition), TO.OTHERS, target,
receiver)
entity.act(
"$n cerca di %s %s $a, ma questi gliel$O ridà." %
(verbs["you2"], preposition), TO.TARGET, target, receiver)
entity.act(
"$n cerca di %s $a, ma gliel%s ridai." %
(verbs["you2"], grammar_gender(target)), TO.TARGET,
receiver, target)
else:
entity.act(
"Cerchi di %s $N %s $a, ma questi te l$O ridà in $hand." %
(verbs["infinitive"], preposition), TO.ENTITY, target,
receiver)
entity.act(
"$n cerca di %s $N %s $a, ma questi gliel$O ridà in $hand."
% (verbs["infinitive"], preposition), TO.OTHERS, target,
receiver)
entity.act(
"$n cerca di %s %s $a, ma questi gliel$O ridà in $hand." %
(verbs["you2"], preposition), TO.TARGET, target, receiver)
entity.act(
"$n cerca di %s $a, ma gliel%s ridai in $hand." %
(verbs["you2"], grammar_gender(target)), TO.TARGET,
receiver, target)
return False
# Se la stanza ha la flag NO_GIVE non permette di dare oggetti
if entity.location.IS_ROOM and noroom in entity.location.flags:
if entity.trust > TRUST.PLAYER:
entity.send_to_admin(
"Questa stanza avrebbe in realtà la flag di NO_GIVE")
else:
if entity.IS_ITEM:
entity.act(
"Appena cerchi di %s $N %s $a%s te l$O ritrovi addosso come se una [royalblue]forza misteriosa[close] nel luogo ti impedisse quest'azione!"
% (verbs["infinitive"], preposition, on_message_you),
TO.ENTITY, target, receiver)
entity.act(
"Appena $n cerca di %s %s $a%s $N se l$O ritrova addosso come se vi fosse una [royalblue]forza misteriosa[close] nel luogo!"
% (verbs["infinitive"], preposition, on_message_it),
TO.OTHERS, target, receiver)
entity.act(
"Appena $n cerca di %s %s $a%s gli ritorni addosso grazie ad una [royalblue]forza misteriosa[close] del luogo!"
% (verbs["you2"], preposition, on_message_it), TO.TARGET,
target, receiver)
entity.act(
"Appena $n cerca di %s $a gli ritorna addosso grazie ad una [royalblue]forza misteriosa[close] del luogo!"
% (verbs["you2"]), TO.TARGET, receiver, target)
else:
entity.act(
"Appena cerchi di %s $N %s $a%s te l$O ritrovi in $hand come se una [royalblue]forza misteriosa[close] nel luogo ti impedisse quest'azione!"
% (verbs["infinitive"], preposition, on_message_you),
TO.ENTITY, target, receiver)
entity.act(
"Appena $n cerca di %s %s $a%s $N se l$O ritrova in $hand come se vi fosse una [royalblue]forza misteriosa[close] nel luogo!"
% (verbs["infinitive"], preposition, on_message_it),
TO.OTHERS, target, receiver)
entity.act(
"Appena $n cerca di %s %s $a%s gli ritorni in $hand grazie ad una [royalblue]forza misteriosa[close] del luogo!"
% (verbs["you2"], preposition, on_message_it), TO.TARGET,
target, receiver)
entity.act(
"Appena $n cerca di %s $a gli ritorna in $hand grazie ad una [royalblue]forza misteriosa[close] del luogo!"
% (verbs["you2"]), TO.TARGET, receiver, target)
return False
# (TD) dare monete
# (TD) gestione dell'argomento all, ultima cosa da supportare
# Se il peso dell'entità da dare supera quello sopportabile dall'obiettivo
# a cui darlo allora avverte e evita l'azione
# (TD) size e carry_number come il get?
if not receiver.can_carry_target(target, quantity=quantity):
if receiver.trust > TRUST.PLAYER:
receiver.send_to_admin(
"Riesci comunque a %s %s anche se è troppo pesante per te." %
(verbs["infinitive"], target.get_name(entity)))
elif entity.trust > TRUST.PLAYER and not receiver.IS_PLAYER:
entity.send_to_admin(
"Riesci comunque a %s %s anche se è troppo pesante per %s." %
(verbs["infinitive"], target.get_name(entity),
receiver.get_name(entity)))
else:
entity.act(
"Non riesci %s %s $N a $a, non può portare con sé tutto quel peso."
% (verbs["infinitive"], preposition), TO.ENTITY, target,
receiver)
entity.act(
"$n non riesce a %s $N %s $a, non può portare con sé tutto quel peso."
% (verbs["infinitive"], preposition), TO.OTHERS, target,
receiver)
entity.act(
"$n non riesce a %s %s $a, non può portare con sé tutto il tuo peso."
% (verbs["you2"], preposition), TO.TARGET, target, receiver)
entity.act(
"$n non riesce a %s $a, non puoi portare con te tutto quel peso."
% verbs["you2"], TO.TARGET, receiver, target)
return False
force_return = check_trigger(entity, "before_" + gamescript_suffix1,
entity, target, receiver, DIR.NONE,
behavioured)
if force_return:
return True
force_return = check_trigger(target, "before_" + gamescript_suffix2,
entity, target, receiver, DIR.NONE,
behavioured)
if force_return:
return True
force_return = check_trigger(receiver, "before_" + gamescript_suffix3,
entity, target, receiver, DIR.NONE,
behavioured)
if force_return:
return True
if on_message_you and on_message_it:
entity.act(
"%s $N %s $a%s." %
(color_first_upper(verbs["you"]), preposition, on_message_you),
TO.ENTITY, target, receiver)
entity.act(
"$n %s $N %s $a%s." % (verbs["it"], preposition, on_message_it),
TO.OTHERS, target, receiver)
entity.act(
"$n ti %s %s $a%s." % (verbs["it"], preposition, on_message_it),
TO.TARGET, target, receiver)
entity.act("$n ti %s $a." % verbs["it"], TO.TARGET, receiver, target)
else:
entity.act(
"%s $N %s $a." % (color_first_upper(verbs["you"]), preposition),
TO.ENTITY, target, receiver)
entity.act("$n %s $N %s $a." % (verbs["it"], preposition), TO.OTHERS,
target, receiver)
entity.act("$n ti %s %s $a." % (verbs["it"], preposition), TO.TARGET,
target, receiver)
entity.act("$n ti %s $a." % verbs["it"], TO.TARGET, receiver, target)
target = target.from_location(quantity, use_repop=True)
target.to_location(receiver)
force_return = check_trigger(entity, "after_" + gamescript_suffix1, entity,
target, receiver, DIR.NONE, behavioured)
if force_return:
return True
force_return = check_trigger(target, "after_" + gamescript_suffix2, entity,
target, receiver, DIR.NONE, behavioured)
if force_return:
return True
force_return = check_trigger(receiver, "after_" + gamescript_suffix3,
entity, target, receiver, DIR.NONE,
behavioured)
if force_return:
return True
return True
def find_entity_from_args(self,
arg,
argument,
quantity=1,
location=None,
entity_tables=None):
"""
Serve a trovare un'entità nell'inventario di self a seconda degli
argomenti passati.
Se vi è un solo argomento allora prende quello (look target).
Se ve ne sono due allora prende il secondo (look extra target).
Se si passa il parametro location allora viene utilizzata la find_entity
e non la find_entity_extensively.
"""
if not arg:
log.bug("arg non è un parametro valido: %r" % arg)
return None, "", ""
if not argument and argument != "":
log.bug("argument non è un parametro valido: %r" % argument)
return None, "", ""
if quantity < 0:
log.bug("quantity non è un parametro valido: %d" % quantity)
return
# -------------------------------------------------------------------------
if not entity_tables:
entity_tables = self.ENTITY_TABLES
if not argument:
target_argument = arg
extra_argument = ""
else:
target_argument = argument
extra_argument = arg
if is_same(target_argument, ("me", "self")):
target = self
else:
if location:
target = self.find_entity(target_argument,
quantity=quantity,
location=location,
entity_tables=entity_tables)
else:
target = self.find_entity_extensively(
target_argument,
quantity=quantity,
entity_tables=entity_tables)
#global get_direction
#if not get_direction:
# from src.room import get_direction
# Se il target è una porta aperta ricavata tramite una direzione allora
# dà la precedenza all'uscita e non alla porta
if (target and target.door_type
and DOOR.CLOSED not in target.door_type.flags
and get_direction(target_argument, exact=False) != DIR.NONE):
return None, target_argument, extra_argument
if quantity == 0:
return target, target_argument, extra_argument
else:
return target.split_entity(
quantity) if target else None, target_argument, extra_argument
def find_entity_extensively(self,
argument,
quantity=1,
entity_tables=None,
inventory_pos="",
direct_search=True,
reverse_search=True,
avoid_inventory=False,
avoid_equipment=False,
avoid_doors=False):
"""
Esegue una ricerca standard, di una entità corrispondente all'argomento
passato, il più estensivamente possibile.
reverse_search serve a indicare se cercare anche le porte dall'altra
parte o meno.
"""
if quantity < 0:
log.bug("quantity non è un parametro valido: %d" % quantity)
return
# ---------------------------------------------------------------------
if not entity_tables:
entity_tables = self.ENTITY_TABLES
original_argument = argument
if inventory_pos == "first":
target = self.find_entity(argument, quantity, self, entity_tables,
[
is_same,
], avoid_inventory, avoid_equipment,
avoid_doors)
if target:
if quantity == 0:
return target
else:
return target.split_entity(quantity)
# Prima esegue una ricerca esatta di tutte le entità attorno
target = self.find_entity(argument, quantity, self.location,
entity_tables, [
is_same,
], avoid_inventory, avoid_equipment,
avoid_doors)
if target:
if quantity == 0:
return target
else:
return target.split_entity(quantity)
if inventory_pos == "":
target = self.find_entity(argument, quantity, self, entity_tables,
[
is_same,
], avoid_inventory, avoid_equipment,
avoid_doors)
if target:
if quantity == 0:
return target
else:
return target.split_entity(quantity)
if self.trust >= TRUST.MASTER:
find_entity_handler_function = _find_entity_handler_for_admin
else:
find_entity_handler_function = _find_entity_handler
if not avoid_doors:
doors = []
if self.location.IS_ROOM:
# (TD) se ci sarà il sistema di più uscite per stanza qui bisognerà
# utilizzare una get_exit, per supportare i vari 1.nord 2.nord, al
# posto della get_direction (idem per il codice simile sottostante)
direction = get_direction(argument, exact=True)
if direction != DIR.NONE:
door = self.location.get_door(direction, direct_search,
reverse_search)
if door and DOOR.NO_USE_DIR not in door.door_type.flags:
return door
for direction in self.location.exits:
door = self.location.get_door(direction, direct_search,
reverse_search)
if door:
doors.append(door)
if doors:
number, argument = number_argument(argument)
target = find_entity_handler_function(
self, argument, doors, number, is_same,
avoid_inventory, avoid_equipment, avoid_doors)
if target:
return target
if inventory_pos == "last":
target = self.find_entity(argument, quantity, self, entity_tables,
[
is_same,
], avoid_inventory, avoid_equipment,
avoid_doors)
if target:
if quantity == 0:
return target
else:
return target.split_entity(quantity)
# Poi esegue una ricerca prefissa delle entità attorno
argument = original_argument
if inventory_pos == "first":
target = self.find_entity(argument, quantity, self, entity_tables,
[
is_prefix,
], avoid_inventory, avoid_equipment,
avoid_doors)
if target:
if quantity == 0:
return target
else:
return target.split_entity(quantity)
target = self.find_entity(argument, quantity, self.location,
entity_tables, [
is_prefix,
], avoid_inventory, avoid_equipment,
avoid_doors)
if target:
if quantity == 0:
return target
else:
return target.split_entity(quantity)
if inventory_pos == "":
target = self.find_entity(argument, quantity, self, entity_tables,
[
is_prefix,
], avoid_inventory, avoid_equipment,
avoid_doors)
if target:
if quantity == 0:
return target
else:
return target.split_entity(quantity)
if not avoid_doors:
# find_entity_handler_function e doors le deve aver già ricavate
# precedentemente
if self.location.IS_ROOM:
direction = get_direction(argument, exact=False)
if direction != DIR.NONE:
door = self.location.get_door(direction, direct_search,
reverse_search)
if door and DOOR.NO_USE_DIR not in door.door_type.flags:
return door
if doors:
number, argument = number_argument(argument)
target = find_entity_handler_function(
self, argument, doors, number, is_prefix,
avoid_inventory, avoid_equipment, avoid_doors)
if target:
return target
if inventory_pos == "last":
target = self.find_entity(argument, quantity, self, entity_tables,
[
is_prefix,
], avoid_inventory, avoid_equipment,
avoid_doors)
if target:
if quantity == 0:
return target
else:
return target.split_entity(quantity)
return None
def five_senses_handler(entity, argument, behavioured, command_name, gamescript_suffix2, sense_name, has_sense_method_name, messages):
if not entity:
log.bug("entity non è un parametro valido: %r" % entity)
return False
# argument può essere una stringa vuota
# behavioured ha valore di verità
if not command_name:
log.bug("command_name non è un parametro valido: %r" % command_name)
return False
if not gamescript_suffix2:
log.bug("gamescript_suffix2 non è un parametro valido: %r" % gamescript_suffix2)
return False
# sense_name può essere una stringa vuota, per il look
if not has_sense_method_name:
log.bug("has_sense_method_name non è un parametro valido: %r" % has_sense_method_name)
return False
if not messages:
log.bug("messages non è un parametro valido: %r" % messages)
return False
# -------------------------------------------------------------------------
entity = entity.split_entity(1)
if entity.IS_ACTOR:
if entity.position < POSITION.SLEEP:
entity.act(messages["death_position_entity"], TO.ENTITY)
entity.act(messages["death_position_others"], TO.OTHERS)
return False
if entity.position == POSITION.SLEEP:
entity.act(messages["sleep_position_entity"], TO.ENTITY)
entity.act(messages["sleep_position_others"], TO.OTHERS)
return False
if not getattr(entity, has_sense_method_name)():
entity.act(messages["not_has_sense_entity"], TO.ENTITY)
entity.act(messages["not_has_sense_others"], TO.OTHERS)
return False
# Se entity è una razza che non può annusare sott'acqua allora esce
if (sense_name == "smell" and not entity.race.smell_on_water
and entity.location.IS_ROOM and ROOM.UNDERWATER in entity.location.flags):
entity.send_output("Stai per annusare quando ti ricordi che qui richieresti di annegare!")
return False
# Se non è stato passato nessun argomento allora procede alla ricerca della
# descrizione sensoriale nella stanza
if not argument:
descr = entity.location.get_descr(sense_name, looker=entity)
if descr and "no_send" not in descr:
update_sensed_rooms(entity, entity.location, command_name)
force_return = check_trigger(entity, "before_" + command_name, entity, entity.location, descr, None, behavioured)
if force_return:
return True
force_return = check_trigger(entity.location, "before_" + gamescript_suffix2, entity, entity.location, descr, None, behavioured)
if force_return:
return True
entity.send_output('''<div style="width:66%%">%s</div>''' % descr, break_line=False)
entity.act(messages["room_descr_others"], TO.OTHERS)
force_return = check_trigger(entity, "after_" + command_name, entity, entity.location, descr, None, behavioured)
if force_return:
return True
force_return = check_trigger(entity.location, "after_" + gamescript_suffix2, entity, entity.location, descr, None, behavioured)
if force_return:
return True
return True
else:
force_return = check_trigger(entity, "before_" + command_name, entity, entity.location, "", None, behavioured)
if force_return:
return False
force_return = check_trigger(entity.location, "before_" + gamescript_suffix2, entity, entity.location, "", None, behavioured)
if force_return:
return False
entity.act(messages["no_argument_entity"], TO.ENTITY)
entity.act(messages["no_argument_others"], TO.OTHERS)
force_return = check_trigger(entity, "after_" + command_name, entity, entity.location, "", None, behavioured)
if force_return:
return False
force_return = check_trigger(entity.location, "after_" + gamescript_suffix2, entity, entity.location, "", None, behavioured)
if force_return:
return False
return False
# ---------------------------------------------------------------------
original_argument = argument
arg1, argument = one_argument(argument)
target, target_argument, extra_argument = entity.find_entity_from_args(arg1, argument)
if ((target and not target.is_secret_door())
or (target and target.is_secret_door() and len(target_argument) >= config.min_secret_arg_len)):
return sense_an_entity(entity, target, extra_argument, command_name, gamescript_suffix2, sense_name, messages, behavioured)
# -------------------------------------------------------------------------
# Cerca un'eventuale extra nella locazione, prima in maniera esatta
extra = entity.location.extras.get_extra(original_argument, exact=True)
if extra:
descr = extra.get_descr(sense_name, looker=entity, parent=entity)
if descr and "no_send" not in descr:
update_sensed_rooms(entity, entity.location, command_name)
force_return = check_trigger(entity, "before_" + command_name, entity, entity.location, descr, extra, behavioured)
if force_return:
return True
force_return = check_trigger(entity.location, "before_" + gamescript_suffix2, entity, entity.location, descr, extra, behavioured)
if force_return:
return True
entity.send_output('''<div style="width:66%%">%s</div>''' % descr, break_line=False)
if EXTRA.NO_LOOK_ACT not in extra.flags:
if "%s" in messages["room_extra_others"]:
word = add_article(extra.keywords.split()[0])
entity.act(messages["room_extra_others"] % add_article(word, GRAMMAR.INDETERMINATE), TO.OTHERS)
else:
entity.act(messages["room_extra_others"], TO.OTHERS)
force_return = check_trigger(entity, "after_" + command_name, entity, entity.location, descr, extra, behavioured)
if force_return:
return True
force_return = check_trigger(entity.location, "after_" + gamescript_suffix2, entity, entity.location, descr, extra, behavioured)
if force_return:
return True
return True
# Gestisce il look in una direzione, prima in maniera esatta
if target_argument:
direction = get_direction(target_argument, exact=True)
if direction != DIR.NONE:
return sense_at_direction(entity, direction, extra_argument, True, command_name, gamescript_suffix2, sense_name, messages, behavioured, "to_dir")
# Cerca un'eventuale extra sensoriale nella stanza, ora in maniera prefissa
extra = entity.location.extras.get_extra(original_argument, exact=False)
if extra:
descr = extra.get_descr(sense_name, looker=entity, parent=entity)
if descr and "no_send" not in descr:
update_sensed_rooms(entity, entity.location, command_name)
force_return = check_trigger(entity, "before_" + command_name, entity, entity.location, descr, extra, behavioured)
if force_return:
return True
force_return = check_trigger(entity.location, "before_" + gamescript_suffix2, entity, entity.location, descr, extra, behavioured)
if force_return:
return True
entity.send_output('''<div style="width:66%%">%s</div>''' % descr, break_line=False)
if EXTRA.NO_LOOK_ACT not in extra.flags:
if "%s" in messages["room_extra_others"]:
word = add_article(extra.keywords.split()[0])
entity.act(messages["room_extra_others"] % add_article(word, GRAMMAR.INDETERMINATE), TO.OTHERS)
else:
entity.act(messages["room_extra_others"], TO.OTHERS)
force_return = check_trigger(entity, "after_" + command_name, entity, entity.location, descr, extra, behavioured)
if force_return:
return True
force_return = check_trigger(entity.location, "after_" + gamescript_suffix2, entity, entity.location, descr, extra, behavioured)
if force_return:
return True
return True
# Gestisce il look in una direzione, ora in maniera prefissa
if target_argument:
direction = get_direction(target_argument, exact=False)
if direction != DIR.NONE:
return sense_at_direction(entity, direction, extra_argument, False, command_name, gamescript_suffix2, sense_name, messages, behavioured, "to_dir")
# -------------------------------------------------------------------------
force_return = check_trigger(entity, "before_" + command_name, entity, None, "", extra, behavioured)
if force_return:
return False
if extra:
word = add_article(extra.keywords.split()[0])
entity.act(messages["no_found_extra_entity_alt"].replace(" di $N", "") % word, TO.ENTITY)
else:
if "%s" in messages["no_found_entity"]:
entity.act(messages["no_found_entity"] % original_argument, TO.ENTITY)
else:
entity.act(messages["no_found_entity"], TO.ENTITY)
entity.act(messages["no_found_others"], TO.OTHERS)
force_return = check_trigger(entity, "after_" + command_name, entity, None, "", extra, behavioured)
if force_return:
return False
return False
def command_flee(entity, argument="", verbs=VERBS, behavioured=False):
if not verbs:
log.bug("verbs non è un parametro valido: %r" % verbs)
return False
# -------------------------------------------------------------------------
# È possibile se il comando è stato deferrato
if not entity:
return False
entity = entity.split_entity(1)
# (TD) Se non si ha la skill non prova neppure a fuggire
pass
followers = []
if not entity.is_fighting():
followers = entity.get_followers_here()
if not followers:
entity.send_output(
"Non stai combattendo contro nessuno e nessuno ti sta seguendo!"
)
return False
# (TD) se l'adrenalina è al massimo o si è in berserker non si può fuggire
if entity.vigour <= 0:
entity.act("Sei troppo stanc$o per poter %s!" % verbs["infinitive"],
TO.ENTITY)
entity.act("$n è troppo stanco per poter %s!" % verbs["infinitive"],
TO.OTHERS)
return False
# (TD) magari in futuro fare la fuga anche tramite comando exit se
# location è un contenitore aperto
if not entity.location.IS_ROOM:
message = {}
messages["entity"] = "Non trovi nessuna via di %s qui dentro!" % verbs[
"noun"]
messages[
"others"] = "$n non trova nessuna via di %s qui dentro!" % verbs[
"noun"]
return flee_with_portal(entity, messages)
# Se non ci sono uscite praticabili allora prova a cercare dei portali,
# da cui è facile fuggire, però non si sa mai dove possano portare...
directions = list(
entity.location.iter_viable_directions(closed_doors=True))
if not directions:
message = {}
messages["entity"] = "Non trovi nessuna via di %s qui dentro!" % verbs[
"noun"]
messages[
"others"] = "$n non trova nessuna via di %s qui dentro!" % verbs[
"noun"]
return flee_with_portal(
entity,
"Non trovi nessuna uscita da cui poter %s!" % verbs["infinitive"])
opponent = entity.get_opponent()
if not opponent:
opponent = random.choice(followers)
if not opponent:
log.bug("Inaspettato: opponent non è valido: %r (entità in fuga: %s)" %
(opponent, entity.code))
return False
for direction in reversed(directions):
door = entity.location.get_door(direction)
if not door:
continue
if opponent == door:
directions.remove(direction)
break
if not directions:
message = {}
messages[
"entity"] = "$N blocca l'unica via di %s disponibile!" % verbs[
"noun"]
messages[
"others"] = "$N blocca a $n l'unica via di %s disponibile!" % verbs[
"noun"]
messages[
"target"] = "Blocchi a $n l'unica via di %s disponibile!" % verbs[
"noun"]
return flee_with_portal(entity, messages, opponent)
# (TD) fino a che il flee non è una skill la fallacità è casuale e
# proporzionale al numero di uscite praticabili della stanza
if random.randint(1, 6) > len(directions):
entity.act(
"Nella foga non riesci ad orientarti e trovare una via di %s!" %
verbs["noun"], TO.ENTITY)
entity.act(
"Nella foga $n non riesce ad orientarti e trovare una via di %s!" %
verbs["noun"], TO.OTHERS)
entity.wait(FLEE_WAIT)
return False
# Tramite queste righe è possibile scegliere dove fuggire, oppure se fugge
# in una direzione a caso
if argument:
direction = get_direction(argument)
else:
direction = random.choice(directions)
# (TD) bisognerà ricordarsi di far fuggire tramite porte se si ha il
# pass door (anche se penso che come effetto costante ai player non lo
# vorrò) però come incantesimo sì, e quindi anche come flag di
exit = entity.location.exits[direction]
if EXIT.NO_FLEE in exit.flags:
entity.act(
"Stai per %s verso %s ma ti rendi conto che ti è impossibile!" %
(verbs["infinitive"], direction), TO.ENTITY)
entity.act(
"$n sta per %s verso %s ma si rendi conto che è impossibile..." %
(verbs["infinitive"], direction), TO.OTHERS)
entity.wait(FLEE_WAIT)
return False
if exit.door and exit.door.door_type:
# Le uscite con le porte chiuse a chiave sono bloccate alla fuga
if DOOR.LOCKED in exit.door.door_type.flags:
entity.act(
"Sbatti contro $N chiusa a chiave, non si può %s da qui!" %
(verbs["infinitive"]), TO.ENTITY, exit.door)
entity.act(
"$n sbatte contro $N chiusa a chiave, non si può %s da lì!" %
(verbs["infinitive"]), TO.OTHERS, exit.door)
entity.wait(FLEE_WAIT)
return False
# Mentre per le porte semplicemente chiuse c'è la possibilità di entrarvi e fuggire
if DOOR.CLOSED in exit.door.door_type.flags:
if random.randint(0, 1) == 0:
# (TD) e magari chiudergliela in faccia
if not command_open(
entity, exit.door.get_numbered_keyword(looker=entity)):
entity.wait(FLEE_WAIT)
return False
else:
entity.act(
"Sbatti contro $N chiusa, non riesci a %s da qui!" %
(verbs["infinitive"]), TO.ENTITY, exit.door)
entity.act(
"$n sbatte contro $N chiusa, non riesce a %s da lì!" %
(verbs["infinitive"]), TO.OTHERS, exit.door)
entity.wait(FLEE_WAIT)
return False
force_return = check_trigger(entity, "before_flee", entity, opponent,
direction, None, behavioured)
if force_return:
return True
force_return = check_trigger(opponent, "before_fleeing", entity, opponent,
direction, None, behavioured)
if force_return:
return True
if followers:
opponent.guide = None
entity.act("$n riesce a %s da $N!" % (verbs["infinitive"]), TO.OTHERS,
opponent)
entity.act("$n riesce a %s!" % (verbs["you2"]), TO.TARGET, opponent)
execution_result = entity.move(direction,
behavioured=behavioured,
fleeing=True)
entity.act("Riesci a %s da $N!" % (verbs["infinitive"]), TO.ENTITY,
opponent)
if not followers:
xp_loss_and_stop_fight(entity, opponent, verbs)
entity.wait(FLEE_WAIT)
force_return = check_trigger(entity, "after_flee", entity, opponent,
direction, None, behavioured)
if force_return:
return True
force_return = check_trigger(opponent, "after_fleeing", entity, opponent,
direction, None, behavioured)
if force_return:
return True
return execution_result
def dig_an_exit(entity, argument, verbs, behavioured):
if not entity:
log.bug("entity non è un parametro valido: %r" % entity)
return False
if not argument:
log.bug("argument non è un parametro valido: %r" % argument)
return False
if not verbs:
log.bug("verbs non è un parametro valido: %r" % verbs)
return False
# behavioured ha valore di verità
# -------------------------------------------------------------------------
location = entity.location
arg, argument = one_argument(argument);
direction = get_direction(arg)
if direction == DIR.NONE:
entity.act("Non trovi nessuna direzione [white]%s[close] in cui %s." % (arg, verbs["infinitive"]), TO.ENTITY, location)
entity.act("$n sembra voler %s in una direzione, ma appare spaesato." % verbs["infinitive"], TO.OTHERS, location)
entity.act("$n sembra voler %s in una direzione, ma appare spaesato." % verbs["you2"], TO.TARGET, location)
return False
if not location.IS_ROOM:
entity.act("Non trovi in un luogo ove poter %s %s." % (verbs["infinitive"], direction.to_dir), TO.ENTITY, location)
entity.act("$n sembra voler %s %s nonostante non si trovi in un luogo con delle uscite." % (verbs["infinitive"], direction.to_dir), TO.OTHERS, location)
entity.act("Non sei un luogo in cui si possa %s %s, eppure $n ci sta provando lo stesso." % (verbs["infinitive"], direction.to_dir), TO.TARGET, location)
return False
# (TD) Questo si potrebbe convertire in metodo se dovesse servire nuovamente
exit = None
has_secret_door = False
if direction in location.exits:
exit = location.exits[direction]
door = location.get_door(direction)
if door and door.door_type and DOOR.SECRET in door.door_type.flags and DOOR.CLOSED in door.door_type.flags:
has_secret_door = True
if exit and EXIT.DIGGABLE not in exit.flags and not has_secret_door:
entity.act("Non sapresti proprio come %s %s: c'è già un'uscita!" % (verbs["infinitive"], direction.to_dir), TO.ENTITY, location)
entity.act("$n sembra voler %s %s: ma c'è già un'uscita!" % (verbs["infinitive"], direction.to_dir), TO.OTHERS, location)
entity.act("$n sembra voler %s %s: ma li hai già un'uscita!" % (verbs["infinitive"], direction.to_dir), TO.TARGET, location)
return False
entity.act("Cominci a %s %s." % (verbs["infinitive"], direction.to_dir), TO.ENTITY, location)
entity.act("$n comincia a %s %s." % (verbs["infinitive"], direction.to_dir), TO.OTHERS, location)
entity.act("$n comincia a %s %s." % (verbs["you2"], direction.to_dir), TO.TARGET, location)
force_return = check_trigger(entity, "before_dig", entity, location, exit, direction, behavioured)
if force_return:
return True
force_return = check_trigger(location, "before_digged", entity, location, exit, direction, behavioured)
if force_return:
return True
# (TD) Togliere un po' di energie nella scavata
if exit and not has_secret_door:
defer_later_function = digging_a_diggable_exit_1
else:
defer_later_function = digging_an_inexistent_exit_1
entity.action_in_progress = ActionInProgress(DIG_SECONDS, defer_later_function, stop_digging_on_exit, entity, location, direction, verbs, behavioured)
return True
def give_or_put(entity, argument, verbs, behavioured, entity_tables, noflag, noroom, gamescript_suffix1, gamescript_suffix2, gamescript_suffix3, preposition):
if not entity:
log.bug("entity non è un parametro valido: %r" % entity)
return False
# argument può essere una stringa vuota
if not verbs:
log.bug("verbs non è un parametro valido: %r" % verbs)
return False
if not entity_tables:
log.bug("entity_tables non è un parametro valido: %r" % entity_tables)
return False
if noflag not in (FLAG.NO_PUT, FLAG.NO_GIVE):
log.bug("noflag non è un parametro valido: %r" % noflag)
return False
if noroom not in (ROOM.NO_PUT, ROOM.NO_GIVE):
log.bug("noroom non è un parametro valido: %r" % noroom)
return False
if gamescript_suffix1 not in ("put", "give"):
log.bug("gamescript_suffix1 non è un parametro valido: %r" % gamescript_suffix1)
return False
if gamescript_suffix2 not in ("putted", "gave"):
log.bug("gamescript_suffix2 non è un parametro valido: %r" % gamescript_suffix2)
return False
if gamescript_suffix3 not in ("putting", "giving"):
log.bug("gamescript_suffix3 non è un parametro valido: %r" % gamescript_suffix3)
return False
if preposition not in ("in", "a"):
log.bug("gamescript_suffix non è un parametro valido: %r" % gamescript_suffix)
return False
# -------------------------------------------------------------------------
entity = entity.split_entity(1)
if not argument:
entity.send_output("Che [white]cosa[close] vorresti %s %s [white]%s[close]?" % (verbs["infinitive"], preposition, "qualcuno" if preposition == "a" else "qualcosa"))
if entity.IS_PLAYER and OPTION.NEWBIE in entity.account.options:
syntax = get_command_syntax(entity, "command_put")
entity.send_output(syntax)
return False
# Ricava l'eventuale quantità d'oggetti da posare
quantity, argument = quantity_argument(argument)
arg1, argument = one_argument(argument)
# (TD) Controllo del mental state deviato
# Ricerca nell'inventario dell'entità quella da dare o mettere
target = entity.find_entity(arg1, quantity=quantity, location=entity)
arg2 = ""
receiver = None
if argument:
arg2, argument = one_argument(argument)
# Rimuove eventuali argomenti facoltativi
if argument and arg2 == "a":
arg2, argument = one_argument(argument)
# Ricerca dell'entità bersaglio a cui dare l'entità target
receiver = entity.find_entity_extensively(arg2, entity_tables=entity_tables)
# Controlla se si vuole inserire una porta sui cardini di un'uscita
direction = get_direction(arg2)
if target and not receiver and direction != DIR.NONE:
if not entity.location.IS_ROOM:
entity.act("Vorresti %s $N sui cardini di un'eventuale uscita %s, ma non ti trovi in una stanza." % (verbs["infinitive"], direction.to_dir), TO.ENTITY, target)
entity.act("$n vorrebbe %s $N sui cardini di un'eventuale uscita %s, ma non vi trovate in una stanza." % (verbs["infinitive"], direction.to_dir), TO.OTHERS, target)
entity.act("$n ti vorrebbe %s sui cardini di un'eventuale uscita %s, ma non vi trovate in una stanza." % (verbs["infinitive"], direction.to_dir), TO.TARGET, target)
return False
if not direction in entity.location.exits:
entity.act("Vorresti %s $N sui cardini di un'eventuale uscita %s, ma questa non esiste." % (verbs["infinitive"], direction.to_dir), TO.ENTITY, target)
entity.act("$n vorrebbe %s $N sui cardini di un'eventuale uscita %s, ma questa non esiste." % (verbs["infinitive"], direction.to_dir), TO.OTHERS, target)
entity.act("$n ti vorrebbe %s sui cardini di un'eventuale uscita %s, ma questa non esiste." % (verbs["infinitive"], direction.to_dir), TO.TARGET, target)
return False
exit_door = entity.location.exits[direction].door
if exit_door:
entity.act("Vorresti %s $N sui cardini dell'uscita %s, ma questa possiede già $a." % (verbs["infinitive"], direction.to_dir), TO.ENTITY, target, exit_door)
entity.act("$n vorrebbe %s $N sui cardini dell'uscita %s, ma questa possiede già $a." % (verbs["infinitive"], direction.to_dir), TO.OTHERS, target, exit_door)
entity.act("$n ti vorrebbe %s sui cardini dell'uscita %s, ma questa possiede già $a." % (verbs["infinitive"], direction.to_dir), TO.TARGET, target, exit_door)
return False
if not target.door_type:
entity.act("Vorresti %s sui cardini dell'uscita %s $N, ma quest'ultim$O non è una porta." % (verbs["infinitive"], direction.to_dir), TO.ENTITY, target, exit_door)
entity.act("$n vorrebbe %s sui cardini dell'uscita %s $N, ma quest'ultim$O non è una porta." % (verbs["infinitive"], direction.to_dir), TO.OTHERS, target, exit_door)
entity.act("$n ti vorrebbe %s sui cardini dell'uscita %s, ma non sei una porta." % (verbs["infinitive"], direction.to_dir), TO.TARGET, target, exit_door)
return False
if quantity > 1:
entity.act("Vorresti %s sui cardini dell'uscita %s $N, ma è possibile inserirne solo un$O." % (verbs["infinitive"], direction.to_dir), TO.ENTITY, target, exit_door)
entity.act("$n vorrebbe %s sui cardini dell'uscita %s $N, ma è possibile inserirne solo un$O" % (verbs["infinitive"], direction.to_dir), TO.OTHERS, target, exit_door)
entity.act("$n ti vorrebbe %s sui cardini dell'uscita %s, ma è possibile inserirti solo in un'unità." % (verbs["infinitive"], direction.to_dir), TO.TARGET, target, exit_door)
return False
force_return = check_trigger(entity, "before_" + gamescript_suffix1, entity, target, None, direction, behavioured)
if force_return:
return True
force_return = check_trigger(target, "before_" + gamescript_suffix2, entity, target, None, direction, behavioured)
if force_return:
return True
force_return = check_trigger(receiver, "before_" + gamescript_suffix3, entity, target, None, direction, behavioured)
if force_return:
return True
entity.act("%s $N sui cardini dell'uscita %s." % (verbs["you"], direction.to_dir), TO.ENTITY, target)
entity.act("$n %s $N sui cardini dell'uscita %s." % (verbs["it"], direction.to_dir), TO.OTHERS, target)
entity.act("$n ti %s sui cardini dell'uscita %s." % (verbs["it"], direction.to_dir), TO.TARGET, target)
target = target.from_location(1)
target.to_location(entity.location)
entity.location.exits[direction].door = target
force_return = check_trigger(entity, "after_" + gamescript_suffix1, entity, target, None, direction, behavioured)
if force_return:
return True
force_return = check_trigger(target, "after_" + gamescript_suffix2, entity, target, None, direction, behavioured)
if force_return:
return True
force_return = check_trigger(receiver, "after_" + gamescript_suffix3, entity, target, None, direction, behavioured)
if force_return:
return True
return True
# -------------------------------------------------------------------------
if not arg2:
arg2 = "qualcuno" if preposition == "a" else "qualcosa"
# Se l'entità a cui dare si trova nell'inventario allora lo indica
on_message_you = ""
on_message_it = ""
if receiver and receiver.location and receiver.location == entity:
if receiver and len(receiver.wear_mode) > 0:
on_message_you = " che stai [khaki]indossando[close]"
on_message_it = " che sta [khaki]indossando[close]"
else:
on_message_you = " nel tuo [yellow]inventario[close]"
on_message_it = " nel suo [yellow]inventario[close]"
# Gestisce le varie combinazioni di entità non trovate e/o uguali
# all'entità che ha digitato il comando
if target:
if not receiver:
entity.act("Cerchi di %s $N %s [white]%s[close] che non trovi da nessuna parte." % (verbs["infinitive"], preposition, arg2), TO.ENTITY, target)
entity.act("$n cerca di %s $N %s [white]%s[close] che non sembra trovare da nessuna parte." % (verbs["infinitive"], preposition, arg2), TO.OTHERS, target)
entity.act("$n cerca di %s %s [white]%s[close] che non sembra trovare da nessuna parte." % (verbs["you2"], preposition, arg2), TO.TARGET, target)
return False
elif receiver == entity:
entity.act("Cerchi di %s $N %s te stess$o, ma è già tu$O!" % (verbs["infinitive"], preposition), TO.ENTITY, target)
entity.act("$n cerca di %s $N %s se stess$o, ma è già su$O." % (verbs["infinitive"], preposition), TO.OTHERS, target)
entity.act("$n cerca di %s $N %s se stess$o, ma è già su$O." % (verbs["infinitive"], preposition), TO.TARGET, target)
return False
elif receiver == target:
entity.act("Cerchi di %s $N %s se stess$o, ma ciò è impossibile!" % (verbs["infinitive"], preposition), TO.ENTITY, target)
entity.act("$n cerca di %s $N %s se stess$o, ma ciò è impossibile." % (verbs["infinitive"], preposition), TO.OTHERS, target)
entity.act("$n cerca di %s $N %s te stess$o, ciò è impossibile." % (verbs["infinitive"], preposition), TO.TARGET, target)
return False
elif not target:
if not receiver:
entity.act("Cerchi di %s [white]%s[close] %s [white]%s[close], ma non trovi nulla e nessuno nel tuo inventario." % (verbs["infinitive"], arg1, preposition, arg2), TO.ENTITY)
entity.act("$n cerca di %s [white]qualcosa[close] %s [white]quacuno[close], ma senza molti risultati nel suo inventario." % (verbs["infinitive"], preposition), TO.OTHERS)
return False
elif receiver == entity:
if entity.IS_ITEM:
entity.act("Cerchi di [orange]passarti [white]%s[close], ma non trovi [gray]nulla del genere[close] nel tuo [yellow]inventario[close]." % arg1, TO.ENTITY, receiver)
entity.act("$n cerca di [orange]passarsi [white]qualcosa[close] che [gray]non sembra trovare[close] nel suo [yellow]inventario[close].", TO.OTHERS, receiver)
else:
entity.act("Cerchi di [orange]passarti[close] da una $hand all'altra [white]%s[close], ma non trovi [gray]nulla del genere[close] nel tuo [yellow]inventario[close]." % arg1, TO.ENTITY, receiver)
entity.act("$n cerca di [orange]passarsi[close] da una $hand all'altra [white]qualcosa[close] che [gray]non sembra trovare[close] nel suo [yellow]inventario[close].", TO.OTHERS, receiver)
return False
else:
if on_message_you and on_message_it:
entity.act("Cerchi di %s un [white]%s[close] %s $N%s, ma non trovi [gray]nulla del genere[close]." % (verbs["infinitive"], arg1, preposition, on_message_you), TO.ENTITY, receiver)
entity.act("$n cerca di %s [white]qualcosa[close] %s $N%s, ma non sembra trovare [gray]nulla del genere[close]." % (verbs["infinitive"], preposition, on_message_it), TO.OTHERS, receiver)
entity.act("$n cerca di %s [white]qualcosa[close], ma non sembra trovare [gray]nulla del genere[close]." % (verbs["infinitive"]), TO.TARGET, receiver)
else:
entity.act("Cerchi di %s un [white]%s[close] %s $N, ma non trovi [gray]nulla del genere[close] nel tuo [yellow]inventario[close]." % (verbs["infinitive"], arg1, preposition), TO.ENTITY, receiver)
entity.act("$n cerca di %s [white]qualcosa[close] %s $N, ma non sembra trovare [gray]nulla del genere[close] nel suo [yellow]inventario[close]." % (verbs["infinitive"], preposition[2 : ]), TO.OTHERS, receiver)
entity.act("$n cerca di %s [white]qualcosa[close], ma non sembra trovare [gray]nulla del genere[close] nel suo [yellow]inventario[close]." % (verbs["infinitive"]), TO.TARGET, receiver)
return False
if quantity == 0:
quantity = target.quantity
elif target.quantity < quantity:
entity.act("Non puoi %s $N perché ne possiedi solo %d e non %d." % (verbs["infinitive"], target.quantity, quantity), TO.ENTITY, target)
entity.act("$n sta cercando di ammucchiare un quantitativo voluto di $N per poterlo %s" % verbs["infinitive"], TO.OTHERS, target)
entity.act("$n sta cercando di ammucchiarti per un quantitativo voluto per poterti %s" % verbs["infinitive"], TO.TARGET, target)
return False
if receiver.container_type and CONTAINER.CLOSED in receiver.container_type.flags:
entity.act("Cerchi di %s $a %s $N ma l$O trovi chius$O." % (verbs["infinitive"], preposition), TO.ENTITY, receiver, target)
entity.act("$n cerca di %s $a %s $N ma l$O trova chius$O." % (verbs["infinitive"], preposition), TO.OTHERS, receiver, target)
return False
# Se l'obiettivo a cui dare l'entità è un oggetto e non è un contenitore
# allora solo gli admin possono eseguire l'azione
if receiver.IS_ITEM and not receiver.container_type:
if entity.trust > TRUST.PLAYER:
entity.send_to_admin("Il ricevitore non è un contenitore ma tu puoi eseguire comunque l'azione")
else:
entity.act("Cerchi di %s $N %s $a, ma quest'ultimo non ti sembra un contenitore." % (verbs["infinitive"], preposition), TO.ENTITY, target, receiver)
entity.act("$n cerca di %s $N %s $a, ma non riesce a trovare modo per farlo non essendo un contenitore." % (verbs["infinitive"], preposition), TO.OTHERS, target, receiver)
entity.act("$n cerca di %s %s $a, ma non sembra riuscirvi visto che quest'ultimo non è un contenitore." % (verbs["you2"], preposition), TO.TARGET, target, receiver)
entity.act("$n cerca di %s $a, ma avrà ben poca fortuna visto che non sei un contenitore." % verbs["you"], TO.TARGET, receiver, target)
return False
# Se l'entità che ha inviato il comando ha la noflag viene evitata
# l'azione
if noflag in entity.flags:
if entity.trust > TRUST.PLAYER:
entity.send_to_admin("Tu avresti in realtà la flag NO_GIVE")
else:
entity.act("Cerchi di %s $N %s $a, ma qualche [blueroyal]forza misteriosa[close] ti blocca l'azione." % (verbs["infinitive"], preposition), TO.ENTITY, target, receiver)
entity.act("$n cerca di %s $N %s $a, ma sembra essere bloccat$n da una [royalblue]forza misteriosa[close]." % (verbs["infinitive"], preposition), TO.OTHERS, target, receiver)
entity.act("$n cerca di %s %s $a, ma sembra essere essere bloccat$o da una [royalblue]forza misteriosa[close]." % (verbs["you2"], preposition), TO.TARGET, target, receiver)
entity.act("$n cerca di %s $a, ma sembre essere bloccat$o da una [royalblue]forza misteriosa[close]." % verbs["you"], TO.TARGET, receiver, target)
return False
# Se l'oggetto da dare ha la flag NO_GIVE allora evita di farsi
if noflag in target.flags:
if entity.trust > TRUST.PLAYER:
entity.send_to_admin("L'entità da dare avrebbe in realtà la flag NO_GIVE")
else:
if entity.IS_ITEM:
entity.act("Appena cerchi di %s $N %s $a te lo ritrovi, con un [cyan]balzo[close] addosso." % (verbs["infinitive"], preposition), TO.ENTITY, target, receiver)
entity.act("Appena $n cerca di %s $N %s $a se lo ritrova, con un [cyan]balzo[close] addosso." % (verbs["infinitive"], preposition), TO.OTHERS, target, receiver)
entity.act("Appena $n cerca di %s %s $a gli [cyan]rimbalzi[close] addosso." % (verbs["you2"], preposition), TO.TARGET, target, receiver)
entity.act("Appena $n cerca di %s $a se lo ritrova, con un [cyan]balzo[close] addosso." % verbs["you2"], TO.TARGET, receiver, target)
else:
entity.act("Appena cerchi di %s $N %s $a te lo ritrovi, con un [cyan]balzo[close], in $hand." % (verbs["infinitive"], preposition), TO.ENTITY, target, receiver)
entity.act("Appena $n cerca di %s $N %s $a se lo ritrova, con un [cyan]balzo[close], in $hand." % (verbs["infinitive"], preposition), TO.OTHERS, target, receiver)
entity.act("Appena $n cerca di %s %s $a gli [cyan]rimbalzi[close] in $hand." % (verbs["you2"], preposition), TO.TARGET, target, receiver)
entity.act("Appena $n cerca di %s $a se lo ritrova, con un [cyan]balzo[close], in $hand." % verbs["you2"], TO.TARGET, receiver, target)
return False
# Se l'entità a cui dare l'oggetto ha la flag NO_GIVE allora non lo accetta
if noflag in receiver.flags:
if entity.trust > TRUST.PLAYER:
entity.send_to_admin("L'entità a cui dare avrebbe in realtà la flag NO_GIVE")
else:
if entity.IS_ITEM:
entity.act("Cerchi di %s $N %s $a, ma questi te l$O ridà." % (verbs["infinitive"], preposition), TO.ENTITY, target, receiver)
entity.act("$n cerca di %s $N %s $a, ma questi gliel$O ridà." % (verbs["infinitive"], preposition), TO.OTHERS, target, receiver)
entity.act("$n cerca di %s %s $a, ma questi gliel$O ridà." % (verbs["you2"], preposition), TO.TARGET, target, receiver)
entity.act("$n cerca di %s $a, ma gliel%s ridai." % (verbs["you2"], grammar_gender(target)), TO.TARGET, receiver, target)
else:
entity.act("Cerchi di %s $N %s $a, ma questi te l$O ridà in $hand." % (verbs["infinitive"], preposition), TO.ENTITY, target, receiver)
entity.act("$n cerca di %s $N %s $a, ma questi gliel$O ridà in $hand." % (verbs["infinitive"], preposition), TO.OTHERS, target, receiver)
entity.act("$n cerca di %s %s $a, ma questi gliel$O ridà in $hand." % (verbs["you2"], preposition), TO.TARGET, target, receiver)
entity.act("$n cerca di %s $a, ma gliel%s ridai in $hand." % (verbs["you2"], grammar_gender(target)), TO.TARGET, receiver, target)
return False
# Se la stanza ha la flag NO_GIVE non permette di dare oggetti
if entity.location.IS_ROOM and noroom in entity.location.flags:
if entity.trust > TRUST.PLAYER:
entity.send_to_admin("Questa stanza avrebbe in realtà la flag di NO_GIVE")
else:
if entity.IS_ITEM:
entity.act("Appena cerchi di %s $N %s $a%s te l$O ritrovi addosso come se una [royalblue]forza misteriosa[close] nel luogo ti impedisse quest'azione!" % (
verbs["infinitive"], preposition, on_message_you), TO.ENTITY, target, receiver)
entity.act("Appena $n cerca di %s %s $a%s $N se l$O ritrova addosso come se vi fosse una [royalblue]forza misteriosa[close] nel luogo!" % (
verbs["infinitive"], preposition, on_message_it), TO.OTHERS, target, receiver)
entity.act("Appena $n cerca di %s %s $a%s gli ritorni addosso grazie ad una [royalblue]forza misteriosa[close] del luogo!" % (
verbs["you2"], preposition, on_message_it), TO.TARGET, target, receiver)
entity.act("Appena $n cerca di %s $a gli ritorna addosso grazie ad una [royalblue]forza misteriosa[close] del luogo!" % (
verbs["you2"]), TO.TARGET, receiver, target)
else:
entity.act("Appena cerchi di %s $N %s $a%s te l$O ritrovi in $hand come se una [royalblue]forza misteriosa[close] nel luogo ti impedisse quest'azione!" % (
verbs["infinitive"], preposition, on_message_you), TO.ENTITY, target, receiver)
entity.act("Appena $n cerca di %s %s $a%s $N se l$O ritrova in $hand come se vi fosse una [royalblue]forza misteriosa[close] nel luogo!" % (
verbs["infinitive"], preposition, on_message_it), TO.OTHERS, target, receiver)
entity.act("Appena $n cerca di %s %s $a%s gli ritorni in $hand grazie ad una [royalblue]forza misteriosa[close] del luogo!" % (
verbs["you2"], preposition, on_message_it), TO.TARGET, target, receiver)
entity.act("Appena $n cerca di %s $a gli ritorna in $hand grazie ad una [royalblue]forza misteriosa[close] del luogo!" % (
verbs["you2"]), TO.TARGET, receiver, target)
return False
# (TD) dare monete
# (TD) gestione dell'argomento all, ultima cosa da supportare
# Se il peso dell'entità da dare supera quello sopportabile dall'obiettivo
# a cui darlo allora avverte e evita l'azione
# (TD) size e carry_number come il get?
if not receiver.can_carry_target(target, quantity=quantity):
if receiver.trust > TRUST.PLAYER:
receiver.send_to_admin("Riesci comunque a %s %s anche se è troppo pesante per te." % (
verbs["infinitive"], target.get_name(entity)))
elif entity.trust > TRUST.PLAYER and not receiver.IS_PLAYER:
entity.send_to_admin("Riesci comunque a %s %s anche se è troppo pesante per %s." % (
verbs["infinitive"], target.get_name(entity), receiver.get_name(entity)))
else:
entity.act("Non riesci %s %s $N a $a, non può portare con sé tutto quel peso." % (verbs["infinitive"], preposition), TO.ENTITY, target, receiver)
entity.act("$n non riesce a %s $N %s $a, non può portare con sé tutto quel peso." % (verbs["infinitive"], preposition), TO.OTHERS, target, receiver)
entity.act("$n non riesce a %s %s $a, non può portare con sé tutto il tuo peso." % (verbs["you2"], preposition), TO.TARGET, target, receiver)
entity.act("$n non riesce a %s $a, non puoi portare con te tutto quel peso." % verbs["you2"], TO.TARGET, receiver, target)
return False
force_return = check_trigger(entity, "before_" + gamescript_suffix1, entity, target, receiver, DIR.NONE, behavioured)
if force_return:
return True
force_return = check_trigger(target, "before_" + gamescript_suffix2, entity, target, receiver, DIR.NONE, behavioured)
if force_return:
return True
force_return = check_trigger(receiver, "before_" + gamescript_suffix3, entity, target, receiver, DIR.NONE, behavioured)
if force_return:
return True
if on_message_you and on_message_it:
entity.act("%s $N %s $a%s." % (color_first_upper(verbs["you"]), preposition, on_message_you), TO.ENTITY, target, receiver)
entity.act("$n %s $N %s $a%s." % (verbs["it"], preposition, on_message_it), TO.OTHERS, target, receiver)
entity.act("$n ti %s %s $a%s." % (verbs["it"], preposition, on_message_it), TO.TARGET, target, receiver)
entity.act("$n ti %s $a." % verbs["it"], TO.TARGET, receiver, target)
else:
entity.act("%s $N %s $a." % (color_first_upper(verbs["you"]), preposition), TO.ENTITY, target, receiver)
entity.act("$n %s $N %s $a." % (verbs["it"], preposition), TO.OTHERS, target, receiver)
entity.act("$n ti %s %s $a." % (verbs["it"], preposition), TO.TARGET, target, receiver)
entity.act("$n ti %s $a." % verbs["it"], TO.TARGET, receiver, target)
target = target.from_location(quantity, use_repop=True)
target.to_location(receiver)
force_return = check_trigger(entity, "after_" + gamescript_suffix1, entity, target, receiver, DIR.NONE, behavioured)
if force_return:
return True
force_return = check_trigger(target, "after_" + gamescript_suffix2, entity, target, receiver, DIR.NONE, behavioured)
if force_return:
return True
force_return = check_trigger(receiver, "after_" + gamescript_suffix3, entity, target, receiver, DIR.NONE, behavioured)
if force_return:
return True
return True
def read_extra_from_location(entity, location, extra_argument, verbs, behavioured):
if not entity:
log.bug("entity non è un parametro valido: %r" % entity)
return False
if not location:
log.bug("location non è un parametro valido: %r" % location)
return False
if not extra_argument:
log.bug("extra_argument non è un parametro valido: %r" % extra_argument)
return False
if not verbs:
log.bug("verbs non è un parametro valido: %r" % verbs)
return False
# behavioured ha valore di verità
# -------------------------------------------------------------------------
# Cerca un'eventuale extra leggibile nella locazione, prima in maniera esatta
extra = location.extras.get_extra(extra_argument, exact=True)
if extra and EXTRA.READABLE in extra.flags:
if can_read(entity, location, verbs, extra):
descr = extra.get_descr("", looker=entity, parent=entity)
if descr:
force_return = check_trigger(entity, "before_read", entity, entity.location, descr, extra, behavioured)
if force_return:
return True
force_return = check_trigger(entity.location, "before_readed", entity, entity.location, descr, extra, behavioured)
if force_return:
return True
entity.send_output('''<div style="width:66%%">%s</div>''' % descr, break_line=False)
if EXTRA.NO_LOOK_ACT not in extra.flags:
entity.act("$n legge %s." % add_article(extra.keywords.split()[0], GRAMMAR.INDETERMINATE), TO.OTHERS)
force_return = check_trigger(entity.location, "after_read", entity, entity.location, descr, extra, behavioured)
if force_return:
return True
force_return = check_trigger(entity.location, "after_readed", entity, entity.location, descr, extra, behavioured)
if force_return:
return True
return True
# Gestisce il read in una direzione, prima in maniera esatta
if extra_argument:
direction = get_direction(extra_argument, True)
if direction != DIR.NONE:
return sense_at_direction(entity, direction, extra_argument, True, "read", "readed", "", MESSAGES, behavioured, "to_dir", readable=True)
# Cerca un'eventuale extra leggibile nella locazione, ora in maniera prefissa
extra = entity.location.extras.get_extra(extra_argument, exact=False)
if extra and EXTRA.READABLE in extra.flags:
if can_read(entity, location, verbs, extra):
descr = extra.get_descr("", looker=entity, parent=entity)
if descr:
force_return = check_trigger(entity, "before_read", entity, entity.location, extra, descr, behavioured)
if force_return:
return True
force_return = check_trigger(entity.location, "before_readed", entity, entity.location, extra, descr, behavioured)
if force_return:
return True
entity.send_output('''<div style="width:66%%">%s</div>''' % descr, break_line=False)
if EXTRA.NO_LOOK_ACT not in extra.flags:
entity.act("$n legge %s." % add_article(extra.keywords.split()[0], GRAMMAR.INDETERMINATE), TO.OTHERS)
force_return = check_trigger(entity.location, "after_read", entity, entity.location, extra, descr, behavioured)
if force_return:
return True
force_return = check_trigger(entity.location, "after_readed", entity, entity.location, extra, descr, behavioured)
if force_return:
return True
return True
# Gestisce il read in una direzione, ora in maniera prefissa
if extra_argument:
direction = get_direction(extra_argument, exact=False)
if direction != DIR.NONE:
return sense_at_direction(entity, direction, extra_argument, False, "read", "readed", "", MESSAGES, behavioured, "to_dir", readable=True)
if extra:
entity.act("Guardi [white]%s[close] ma non vedi nulla di speciale da %s." % (extra_argument, verbs["infinitive"]), TO.ENTITY)
else:
entity.act("Non vedi nessun [green]%s[close] qui attorno da %s" % (extra_argument, verbs["infinitive"]), TO.ENTITY)
entity.act("$n si guarda attorno alla ricerca di qualcuno o qualcosa che non trova", TO.OTHERS)
return False
def find_entity_extensively(self, argument, quantity=1, entity_tables=None, inventory_pos="", direct_search=True, reverse_search=True, avoid_inventory=False, avoid_equipment=False, avoid_doors=False):
"""
Esegue una ricerca standard, di una entità corrispondente all'argomento
passato, il più estensivamente possibile.
reverse_search serve a indicare se cercare anche le porte dall'altra
parte o meno.
"""
if quantity < 0:
log.bug("quantity non è un parametro valido: %d" % quantity)
return
# ---------------------------------------------------------------------
if not entity_tables:
entity_tables = self.ENTITY_TABLES
original_argument = argument
if inventory_pos == "first":
target = self.find_entity(argument, quantity, self, entity_tables, [is_same, ], avoid_inventory, avoid_equipment, avoid_doors)
if target:
if quantity == 0:
return target
else:
return target.split_entity(quantity)
# Prima esegue una ricerca esatta di tutte le entità attorno
target = self.find_entity(argument, quantity, self.location, entity_tables, [is_same, ], avoid_inventory, avoid_equipment, avoid_doors)
if target:
if quantity == 0:
return target
else:
return target.split_entity(quantity)
if inventory_pos == "":
target = self.find_entity(argument, quantity, self, entity_tables, [is_same, ], avoid_inventory, avoid_equipment, avoid_doors)
if target:
if quantity == 0:
return target
else:
return target.split_entity(quantity)
if self.trust >= TRUST.MASTER:
find_entity_handler_function = _find_entity_handler_for_admin
else:
find_entity_handler_function = _find_entity_handler
if not avoid_doors:
doors = []
if self.location.IS_ROOM:
# (TD) se ci sarà il sistema di più uscite per stanza qui bisognerà
# utilizzare una get_exit, per supportare i vari 1.nord 2.nord, al
# posto della get_direction (idem per il codice simile sottostante)
direction = get_direction(argument, exact=True)
if direction != DIR.NONE:
door = self.location.get_door(direction, direct_search, reverse_search)
if door and DOOR.NO_USE_DIR not in door.door_type.flags:
return door
for direction in self.location.exits:
door = self.location.get_door(direction, direct_search, reverse_search)
if door:
doors.append(door)
if doors:
number, argument = number_argument(argument)
target = find_entity_handler_function(self, argument, doors, number, is_same, avoid_inventory, avoid_equipment, avoid_doors)
if target:
return target
if inventory_pos == "last":
target = self.find_entity(argument, quantity, self, entity_tables, [is_same, ], avoid_inventory, avoid_equipment, avoid_doors)
if target:
if quantity == 0:
return target
else:
return target.split_entity(quantity)
# Poi esegue una ricerca prefissa delle entità attorno
argument = original_argument
if inventory_pos == "first":
target = self.find_entity(argument, quantity, self, entity_tables, [is_prefix, ], avoid_inventory, avoid_equipment, avoid_doors)
if target:
if quantity == 0:
return target
else:
return target.split_entity(quantity)
target = self.find_entity(argument, quantity, self.location, entity_tables, [is_prefix, ], avoid_inventory, avoid_equipment, avoid_doors)
if target:
if quantity == 0:
return target
else:
return target.split_entity(quantity)
if inventory_pos == "":
target = self.find_entity(argument, quantity, self, entity_tables, [is_prefix, ], avoid_inventory, avoid_equipment, avoid_doors)
if target:
if quantity == 0:
return target
else:
return target.split_entity(quantity)
if not avoid_doors:
# find_entity_handler_function e doors le deve aver già ricavate
# precedentemente
if self.location.IS_ROOM:
direction = get_direction(argument, exact=False)
if direction != DIR.NONE:
door = self.location.get_door(direction, direct_search, reverse_search)
if door and DOOR.NO_USE_DIR not in door.door_type.flags:
return door
if doors:
number, argument = number_argument(argument)
target = find_entity_handler_function(self, argument, doors, number, is_prefix, avoid_inventory, avoid_equipment, avoid_doors)
if target:
return target
if inventory_pos == "last":
target = self.find_entity(argument, quantity, self, entity_tables, [is_prefix, ], avoid_inventory, avoid_equipment, avoid_doors)
if target:
if quantity == 0:
return target
else:
return target.split_entity(quantity)
return None
def command_flee(entity, argument="", verbs=VERBS, behavioured=False):
if not verbs:
log.bug("verbs non è un parametro valido: %r" % verbs)
return False
# -------------------------------------------------------------------------
# È possibile se il comando è stato deferrato
if not entity:
return False
entity = entity.split_entity(1)
# (TD) Se non si ha la skill non prova neppure a fuggire
pass
followers = []
if not entity.is_fighting():
followers = entity.get_followers_here()
if not followers:
entity.send_output("Non stai combattendo contro nessuno e nessuno ti sta seguendo!")
return False
# (TD) se l'adrenalina è al massimo o si è in berserker non si può fuggire
if entity.vigour <= 0:
entity.act("Sei troppo stanc$o per poter %s!" % verbs["infinitive"], TO.ENTITY)
entity.act("$n è troppo stanco per poter %s!" % verbs["infinitive"], TO.OTHERS)
return False
# (TD) magari in futuro fare la fuga anche tramite comando exit se
# location è un contenitore aperto
if not entity.location.IS_ROOM:
message = {}
messages["entity"] = "Non trovi nessuna via di %s qui dentro!" % verbs["noun"]
messages["others"] = "$n non trova nessuna via di %s qui dentro!" % verbs["noun"]
return flee_with_portal(entity, messages)
# Se non ci sono uscite praticabili allora prova a cercare dei portali,
# da cui è facile fuggire, però non si sa mai dove possano portare...
directions = list(entity.location.iter_viable_directions(closed_doors=True))
if not directions:
message = {}
messages["entity"] = "Non trovi nessuna via di %s qui dentro!" % verbs["noun"]
messages["others"] = "$n non trova nessuna via di %s qui dentro!" % verbs["noun"]
return flee_with_portal(entity, "Non trovi nessuna uscita da cui poter %s!" % verbs["infinitive"])
opponent = entity.get_opponent()
if not opponent:
opponent = random.choice(followers)
if not opponent:
log.bug("Inaspettato: opponent non è valido: %r (entità in fuga: %s)" % (opponent, entity.code))
return False
for direction in reversed(directions):
door = entity.location.get_door(direction)
if not door:
continue
if opponent == door:
directions.remove(direction)
break;
if not directions:
message = {}
messages["entity"] = "$N blocca l'unica via di %s disponibile!" % verbs["noun"]
messages["others"] = "$N blocca a $n l'unica via di %s disponibile!" % verbs["noun"]
messages["target"] = "Blocchi a $n l'unica via di %s disponibile!" % verbs["noun"]
return flee_with_portal(entity, messages, opponent)
# (TD) fino a che il flee non è una skill la fallacità è casuale e
# proporzionale al numero di uscite praticabili della stanza
if random.randint(1, 6) > len(directions):
entity.act("Nella foga non riesci ad orientarti e trovare una via di %s!" % verbs["noun"], TO.ENTITY)
entity.act("Nella foga $n non riesce ad orientarti e trovare una via di %s!" % verbs["noun"], TO.OTHERS)
entity.wait(FLEE_WAIT)
return False
# Tramite queste righe è possibile scegliere dove fuggire, oppure se fugge
# in una direzione a caso
if argument:
direction = get_direction(argument)
else:
direction = random.choice(directions)
# (TD) bisognerà ricordarsi di far fuggire tramite porte se si ha il
# pass door (anche se penso che come effetto costante ai player non lo
# vorrò) però come incantesimo sì, e quindi anche come flag di
exit = entity.location.exits[direction]
if EXIT.NO_FLEE in exit.flags:
entity.act("Stai per %s verso %s ma ti rendi conto che ti è impossibile!" % (verbs["infinitive"], direction), TO.ENTITY)
entity.act("$n sta per %s verso %s ma si rendi conto che è impossibile..." % (verbs["infinitive"], direction), TO.OTHERS)
entity.wait(FLEE_WAIT)
return False
if exit.door and exit.door.door_type:
# Le uscite con le porte chiuse a chiave sono bloccate alla fuga
if DOOR.LOCKED in exit.door.door_type.flags:
entity.act("Sbatti contro $N chiusa a chiave, non si può %s da qui!" % (verbs["infinitive"]), TO.ENTITY, exit.door)
entity.act("$n sbatte contro $N chiusa a chiave, non si può %s da lì!" % (verbs["infinitive"]), TO.OTHERS, exit.door)
entity.wait(FLEE_WAIT)
return False
# Mentre per le porte semplicemente chiuse c'è la possibilità di entrarvi e fuggire
if DOOR.CLOSED in exit.door.door_type.flags:
if random.randint(0, 1) == 0:
# (TD) e magari chiudergliela in faccia
if not command_open(entity, exit.door.get_numbered_keyword(looker=entity)):
entity.wait(FLEE_WAIT)
return False
else:
entity.act("Sbatti contro $N chiusa, non riesci a %s da qui!" % (verbs["infinitive"]), TO.ENTITY, exit.door)
entity.act("$n sbatte contro $N chiusa, non riesce a %s da lì!" % (verbs["infinitive"]), TO.OTHERS, exit.door)
entity.wait(FLEE_WAIT)
return False
force_return = check_trigger(entity, "before_flee", entity, opponent, direction, None, behavioured)
if force_return:
return True
force_return = check_trigger(opponent, "before_fleeing", entity, opponent, direction, None, behavioured)
if force_return:
return True
if followers:
opponent.guide = None
entity.act("$n riesce a %s da $N!" % (verbs["infinitive"]), TO.OTHERS, opponent)
entity.act("$n riesce a %s!" % (verbs["you2"]), TO.TARGET, opponent)
execution_result = entity.move(direction, behavioured=behavioured, fleeing=True)
entity.act("Riesci a %s da $N!" % (verbs["infinitive"]), TO.ENTITY, opponent)
if not followers:
xp_loss_and_stop_fight(entity, opponent, verbs)
entity.wait(FLEE_WAIT)
force_return = check_trigger(entity, "after_flee", entity, opponent, direction, None, behavioured)
if force_return:
return True
force_return = check_trigger(opponent, "after_fleeing", entity, opponent, direction, None, behavioured)
if force_return:
return True
return execution_result
def command_addexit(entity, argument=""):
if not entity:
log.bug("entity non è un parametro valido: %r" % entity)
return False
# -------------------------------------------------------------------------
if not argument:
syntax = get_command_syntax(entity, "command_addexit")
entity.send_output(syntax, break_line=False)
return False
if not entity.location.IS_ROOM:
entity.send_output("Non ti trovi in una stanza ma in %s" %
entity.location.code)
return False
room = entity.location
arg1, argument = one_argument(argument)
direction = get_direction(arg1)
if direction == DIR.NONE:
entity.send_output("Direzione non valida ricavata dall'argomento %s" %
arg1)
return False
if direction in room.exits:
if room.exits[direction].destination:
destination_message = " che porta a %s" % room.exits[
direction].destination
else:
destination_message = ""
entity.send_output(
"C'è già un uscita %s%s, non puoi aggiungerne un'altra se non rimuovendola con il comando [limegreen]delexit[close] con il comando [limegreen]modifyexit[close]."
% (direction.to_dir))
return False
# Supporto per la destinazione
destination = None
if argument:
args = multiple_arguments(argument)
if len(args) not in (3, 4):
entity.send_output(
"Sintassi del comando non valida, se si vuole specificare una destinazione servono le relative coordinate ed eventualmente il codice dell'area."
)
return False
if not is_number(args[0]):
entity.send_output("La coordinata X non è un numero valido: %s" %
args[0])
return False
if not is_number(args[1]):
entity.send_output("La coordinata Y non è un numero valido: %s" %
args[1])
return False
if not is_number(args[2]):
entity.send_output("La coordinata Z non è un numero valido: %s" %
args[2])
return False
if len(args) == 4:
area = get_area_from_argument(args[3])
if not area:
entity.send_output("Area non trovata con argomento %s" %
args[3])
return False
else:
area = entity.area
destination = Destination(int(args[0]), int(args[1]), int(args[2]),
area)
# Crea la nuova uscita da zero
exit = Exit(direction)
if destination:
exit.destination = destination
room.exits[direction] = exit
entity.send_output("E' stata aggiunta l'uscita %s." % direction.to_dir)
return True