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 command_extract(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_extract")
entity.send_output(syntax, break_line=False)
return False
arg, argument = one_argument(argument)
if argument:
quantity, argument = quantity_argument(argument)
else:
quantity = 1
target = entity.find_entity_extensively(arg, quantity=quantity)
if not target:
entity.send_output("Nessuna entità trovata con argomento [white]%s[close]." % arg)
return False
if target.IS_PLAYER:
entity.send_output("Non ti è possibile estrarre dei personaggi, se c'è un problema con un giocatore contattare i capoccia del Mud.")
return False
if quantity == 0:
quantity = target.quantity
entity.act("Esegui uno extract su $N!", TO.ENTITY, target)
entity.act("$n esegue un extract su $N!", TO.OTHERS, target)
target.act("$n esegue un extract su di te!", TO.TARGET, target)
target.extract(quantity, use_repop=True)
return True
def interpret_or_echo(entity, argument, looker=None, behavioured=False):
if not entity:
log.bug("entity non è un parametro valido: %r" % entity)
return
if not argument:
log.bug("argument non è un parametro valido: %r" % argument)
return
# -------------------------------------------------------------------------
if MIML_SEPARATOR in argument:
argument = entity.parse_miml(argument)
if not argument:
return
if "$" in argument:
argument = looker.replace_act_tags(argument, target=entity)
if "$" in argument:
argument = looker.replace_act_tags_name(argument, looker=looker, target=entity)
original_argument = argument
arg, argument = one_argument(argument)
input, huh_input, lang = multiple_search_on_inputs(entity, arg, exact=True)
if input:
interpret(entity, original_argument, use_check_alias=False, show_input=False, show_prompt=False, behavioured=behavioured)
else:
entity.location.echo(original_argument)
def command_setrace(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_setrace")
entity.send_output(syntax, break_line=False)
return False
arg, argument = one_argument(argument)
target = entity.find_entity_extensively(arg)
if not target:
entity.send_output(
"Nessuna entità trovata con argomento [white]%s[close]" % arg)
return False
if not argument:
entity.send_output("Che razza vuoi impostare a [white]%s[close]?" %
target.get_name(entity))
return False
new_race = get_element_from_name(RACE, argument)
if not new_race:
new_race = get_enum_element(argument, quiet=True)
if not new_race:
new_race = get_enum_element("RACE." + argument.upper(), quiet=True)
if not new_race:
entity.send_output(
"Nessuna razza trovata con argomento [white]%s[close]" %
argument)
return False
if target.race == new_race:
if target == entity:
entity.send_output("La tua razza è già %s" % new_race)
else:
entity.send_output("La razza di %s è già %s" %
(target.get_name(looker), new_race))
return False
if target == entity:
entity.send_output("Cambi la tua razza da %s in %s." %
(target.race, new_race))
else:
entity.send_output("Cambi la razza dell'entità %s da %s in %s." %
(target.get_name(entity), target.race, new_race))
target.race = new_race
return True
def get_see_also_links(entity, see_also):
if not entity:
log.bug("entity non è un parametro valido: %r" % entity)
return ""
if not see_also:
log.bug("see_also non è un parametro valido: %r" % see_also)
return ""
# -------------------------------------------------------------------------
help_translation = translate_input(entity, "help", "en")
if not help_translation:
log.bug("help_translation non valido: %r" % help_translation)
help_translation = "aiuto"
output = "[white]Vedi anche[close]: "
# Supporto ai SeeAlso composti da solo link
if see_also.lower().startswith("<a "):
return output + see_also
for help_code in see_also.split():
help_code = help_code.strip(",")
if help_code not in database["helps"]:
log.bug("help_code %s non si trova tra gli helps" % help_code)
continue
help = database["helps"][help_code]
if entity.IS_PLAYER and OPTION.ITALIAN in entity.account.options:
help_keyword, dummy = one_argument(help.italian_keywords)
else:
help_keyword, dummy = one_argument(help.english_keywords)
javascript_code = '''javascript:parent.sendInput('%s %s');''' % (
help_translation, help_keyword)
output += '''<a href="%s">%s</a>, ''' % (javascript_code, help_keyword)
return output.rstrip(", ")
def get_see_also_links(entity, see_also):
if not entity:
log.bug("entity non è un parametro valido: %r" % entity)
return ""
if not see_also:
log.bug("see_also non è un parametro valido: %r" % see_also)
return ""
# -------------------------------------------------------------------------
help_translation = translate_input(entity, "help", "en")
if not help_translation:
log.bug("help_translation non valido: %r" % help_translation)
help_translation = "aiuto"
output = "[white]Vedi anche[close]: "
# Supporto ai SeeAlso composti da solo link
if see_also.lower().startswith("<a "):
return output + see_also
for help_code in see_also.split():
help_code = help_code.strip(",")
if help_code not in database["helps"]:
log.bug("help_code %s non si trova tra gli helps" % help_code)
continue
help = database["helps"][help_code]
if entity.IS_PLAYER and OPTION.ITALIAN in entity.account.options:
help_keyword, dummy = one_argument(help.italian_keywords)
else:
help_keyword, dummy = one_argument(help.english_keywords)
javascript_code = '''javascript:parent.sendInput('%s %s');''' % (
help_translation, help_keyword)
output += '''<a href="%s">%s</a>, ''' % (javascript_code, help_keyword)
return output.rstrip(", ")
def command_usedrooms(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_usedrooms")
entity.send_output(syntax, break_line=False)
return False
number_of_resets = 0
arg, argument = one_argument(argument)
try:
number_of_resets = int(arg)
except ValueError:
entity.send_output("Il primo argomento dev'essere un [white]numero[close] che rappresenta la quantità di [blue]reset[close] voluti.")
return False
proto_room_resets_counter = {}
for proto_room_code in database["proto_rooms"]:
if argument and not is_prefix(argument, proto_room_code):
continue
reset_counter = 0
for room_code in database["rooms"]:
if is_prefix(proto_room_code, room_code):
reset_counter += 1
proto_room_resets_counter[proto_room_code] = reset_counter
for proto_room_code, reset_counter in proto_room_resets_counter.iteritems():
if reset_counter == number_of_resets:
entity.send_output("%s: %s" % (proto_room_code, database["proto_rooms"][proto_room_code].name))
if len(proto_room_resets_counter) > 0:
entity.send_output("\n")
plural = "a" if len(proto_room_resets_counter) == 1 else "e"
result = "Trovat%s [white]%d[close] stanz%s prototipo resettate [white]%d[close] volte" % (
plural, len(proto_room_resets_counter), plural, number_of_resets)
if argument:
result += " il cui codice è (o inizia per) [white]%s[close]" % argument
else:
result += "."
entity.send_output(result)
return True
def command_setrace(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_setrace")
entity.send_output(syntax, break_line=False)
return False
arg, argument = one_argument(argument)
target = entity.find_entity_extensively(arg)
if not target:
entity.send_output("Nessuna entità trovata con argomento [white]%s[close]" % arg)
return False
if not argument:
entity.send_output("Che razza vuoi impostare a [white]%s[close]?" % target.get_name(entity))
return False
new_race = get_element_from_name(RACE, argument)
if not new_race:
new_race = get_enum_element(argument, quiet=True)
if not new_race:
new_race = get_enum_element("RACE." + argument.upper(), quiet=True)
if not new_race:
entity.send_output("Nessuna razza trovata con argomento [white]%s[close]" % argument)
return False
if target.race == new_race:
if target == entity:
entity.send_output("La tua razza è già %s" % new_race)
else:
entity.send_output("La razza di %s è già %s" % (target.get_name(looker), new_race))
return False
if target == entity:
entity.send_output("Cambi la tua razza da %s in %s." % (target.race, new_race))
else:
entity.send_output("Cambi la razza dell'entità %s da %s in %s." %(target.get_name(entity), target.race, new_race))
target.race = new_race
return True
def command_usedexits(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_usedexits")
entity.send_output(syntax, break_line=False)
return False
number_of_exits = 0
arg, argument = one_argument(argument)
try:
number_of_exits = int(arg)
except ValueError:
entity.send_output(
"Il primo argomento dev'essere un numero che rappresenta la quantità di uscite volute."
)
return False
counter = 0
for room in database["rooms"].itervalues():
if len(room.exits) == number_of_exits:
entity.send_output("%s: %s" % (room.code, room.name))
counter += 1
if counter > 0:
entity.send_output("\n")
plural = "a" if counter == 1 else "e"
result = "Trovat%s [white]%d[close] stanz%s con [white]%d[close] uscite" % (
plural, counter, plural, number_of_exits)
if arg2:
result += " il cui codice è (o inizia per) [white]%s[close]" % arg2
else:
result += "."
entity.send_output(result)
return True
def commands_skills_socials_handler(entity, argument, inputs_type):
if not entity:
log.bug("entity non è un parametro valido: %r" % entity)
return False
# argument può essere una stringa vuota
if not inputs_type:
log.bug("inputs_type non è un parametro valido: %r" % inputs_type)
return False
# -------------------------------------------------------------------------
arg, argument = one_argument(argument)
# Ricava in che lingua visualizzare i comandi
language = "en"
if entity.IS_PLAYER and OPTION.ITALIAN in entity.account.options:
language = "it"
if arg:
if is_same(arg, ("italiano", "italian")):
language = "it"
if is_same(arg, ("inglese", "english")):
language = "en"
# Esegue il controllo degli argomenti
if not arg or is_same(arg, ("italiano", "italian", "inglese", "english")):
return show_list_normal(entity, language, inputs_type)
elif is_same(arg,
("traduzione", "translation", "traduzioni", "translations")):
return show_list_translation(entity, language, inputs_type)
elif inputs_type == "command" and is_same(
arg, ("tipo", "type", "tipi", "types")):
return show_list_type(entity, language, inputs_type)
elif entity.trust >= TRUST.MASTER and is_same(
arg, ("fiducia", "trust", "fiduce", "trusts")):
return show_list_trust(entity, language, inputs_type)
else:
return show_list_found(entity, language, inputs_type, arg)
def command_usedexits(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_usedexits")
entity.send_output(syntax, break_line=False)
return False
number_of_exits = 0
arg, argument = one_argument(argument)
try:
number_of_exits = int(arg)
except ValueError:
entity.send_output("Il primo argomento dev'essere un numero che rappresenta la quantità di uscite volute.")
return False
counter = 0
for room in database["rooms"].itervalues():
if len(room.exits) == number_of_exits:
entity.send_output("%s: %s" % (room.code, room.name))
counter += 1
if counter > 0:
entity.send_output("\n")
plural = "a" if counter == 1 else "e"
result = "Trovat%s [white]%d[close] stanz%s con [white]%d[close] uscite" % (
plural, counter, plural, number_of_exits)
if arg2:
result += " il cui codice è (o inizia per) [white]%s[close]" % arg2
else:
result += "."
entity.send_output(result)
return True
def commands_skills_socials_handler(entity, argument, inputs_type):
if not entity:
log.bug("entity non è un parametro valido: %r" % entity)
return False
# argument può essere una stringa vuota
if not inputs_type:
log.bug("inputs_type non è un parametro valido: %r" % inputs_type)
return False
# -------------------------------------------------------------------------
arg, argument = one_argument(argument)
# Ricava in che lingua visualizzare i comandi
language = "en"
if entity.IS_PLAYER and OPTION.ITALIAN in entity.account.options:
language = "it"
if arg:
if is_same(arg, ("italiano", "italian")):
language = "it"
if is_same(arg, ("inglese", "english")):
language = "en"
# Esegue il controllo degli argomenti
if not arg or is_same(arg, ("italiano", "italian", "inglese", "english")):
return show_list_normal(entity, language, inputs_type)
elif is_same(arg, ("traduzione", "translation", "traduzioni", "translations")):
return show_list_translation(entity, language, inputs_type)
elif inputs_type == "command" and is_same(arg, ("tipo", "type", "tipi", "types")):
return show_list_type(entity, language, inputs_type)
elif entity.trust >= TRUST.MASTER and is_same(arg, ("fiducia", "trust", "fiduce", "trusts")):
return show_list_trust(entity, language, inputs_type)
else:
return show_list_found(entity, language, inputs_type, arg)
def interpret_or_echo(entity, argument, looker=None, behavioured=False):
if not entity:
log.bug("entity non è un parametro valido: %r" % entity)
return
if not argument:
log.bug("argument non è un parametro valido: %r" % argument)
return
# -------------------------------------------------------------------------
if MIML_SEPARATOR in argument:
argument = entity.parse_miml(argument)
if not argument:
return
if "$" in argument:
argument = looker.replace_act_tags(argument, target=entity)
if "$" in argument:
argument = looker.replace_act_tags_name(argument,
looker=looker,
target=entity)
original_argument = argument
arg, argument = one_argument(argument)
input, huh_input, lang = multiple_search_on_inputs(entity, arg, exact=True)
if input:
interpret(entity,
original_argument,
use_check_alias=False,
show_input=False,
show_prompt=False,
behavioured=behavioured)
else:
entity.location.echo(original_argument)
def rpg_channel(entity,
argument,
channel,
ask=False,
exclaim=False,
behavioured=False):
"""
Gestisce i canali rpg, ha le seguenti caratteristiche:
- supporto per gli smile
- supporto per i modi di esprimersi con esclamativo e punto di domanda
- supporto per gli emote
- gestione del bersaglio che può essere un'entità, il gruppo o sé stessi
- (TD) parlata da ubriaco
- (TD) espansione della potenza della voce in altre stanze
- (TD) espressioni per le stanze attorno, anche per coloro che riconoscono la voce,
pensare anche alla suddivisione tra social gestuali e 'rumorosi' per gli smile-espressioni around
- (TD) modulazione della voce a seconda delle dimensioni di chi parla e della sua voice_potence
"""
if not entity:
log.bug("entity non è un parametro valido: %r" % entity)
return False
if not channel:
log.bug("channel non è un parametro valido: %r" % channel)
return False
# -------------------------------------------------------------------------
if entity.IS_ROOM:
return False
objective = OBJECTIVE_ROOM # obiettivo del messaggio
# Linguaggio utilizzato per dire il messaggio
if entity.IS_ITEM:
language = LANGUAGE.COMMON
else:
language = entity.speaking
smile = "" # conterrà l'eventuale espressione di uno smile-social
emote = "" # conterrà l'eventuale emote inviato con il messaggio tra due asterischi
expres_entity = "" # espressione per chi parla
expres_room = "" # espressione per chi sta ascoltando nella stanza
expres_objective = "" # espressione per chi riceverà il messaggio
# Ricava i verbi e il colore relativi al canale
# Se si sta parlando normalmente la propria lingua vengono utilizzati
# i verbi razziali per descriverne timbro, flessione o pronuncia
if channel == CHANNEL.SAY:
verb_you, verb_it = entity.race.say_verb_you, entity.race.say_verb_it
else:
verb_you, verb_it = channel.verb_you, channel.verb_it
color = get_first_color(channel.name)
# Se non è stato passato nessun messaggio esce
if not argument or not remove_colors(argument):
entity.send_output("Cosa vorresti %s?" % channel)
return False
if len(argument) > config.max_google_translate:
entity.send_output("Non puoi %s un messaggio così logorroico." %
channel)
return False
# Copia l'argomento originale, in alcuni casi serve recuperarlo poi
original_argument = argument
# Controlla se si sta parlando a qualcuno, il controllo sulla particella
# la esegue in minuscolo, dando per sottinteso che quando uno scrive
# maiuscolo voglia iniziare un discorso
target = None
if argument[0:2] == "a ":
arg, argument = one_argument(argument)
# Se sta parlando a qualcuno cerca di acquisirlo dal nome successivo
objective_name, argument = one_argument(argument)
target = entity.find_entity_extensively(objective_name)
# con me e self esegue un check senza la is_same volutamente, per evitare
# ricerche con nome di player che iniziano con Me o Self
if target == entity or objective_name in ("me", "self"):
objective = OBJECTIVE_SELF
# Se si parla da soli lo si fa utilizzando la lingua madre
language = entity.race.natural_language
elif target:
objective = OBJECTIVE_TARGET
# Se si parla con qualcuno della stessa razza lo si fa utilizzando
# la lingua preferita dalla razza, è un fattore culturale
if entity.race == target.race:
language = entity.race.natural_language
else:
# Se non ha trovato nessun 'a <nome bersaglio>' riprende
# l'argument originale
argument = original_argument
# Stessa cosa di sopra ma qui controlla se si stia parlando al gruppo
elif argument[0:3] == "al ":
arg, argument = one_argument(argument)
objective_name, argument = one_argument(argument)
if is_prefix(objective_name, "gruppo"):
if not entity.group:
entity.send_output("Non fai parte di nessun gruppo.")
return False
# Questa variabile verrà utilizza poi nell'invio del messaggio
group_members = entity.get_members_here(entity.location)
if not group_members:
entity.send_output(
"Non trovi nessun membro del gruppo vicino a te con cui poter parlare."
)
return False
objective = OBJECTIVE_GROUP
# Se si parla in un gruppo in cui tutti sono formati dalla stessa
# razza si preferirà parlare con la lingua della propria razza
for group_member in group_members:
if group_member.race != entity.race:
break
else:
language = entity.race.natural_language
else:
# Se il personaggio non vuole parlare al gruppo recupera
# il valore originale inviato
argument = original_argument
# (TD) Gestisce il caso in cui l'entità si trovi immersa in un liquido
#if entity.is_immersed():
# entity.send_output("Tenti di %s qualcosa ma subito l'acqua ti riempie la gola soffocandoti!" % channel)
# entity.points.life -= random.randint(entity.level / 6, entity.level / 4) + 1
# return False
if not entity.location:
log.bug(
"entity %s non si trova in una locazione valida: %r (original_argument: %s)"
% (entity.code, entity.location, original_argument))
return False
# Gestisce le stanze che obbligano al silenzio
if entity.location.IS_ROOM:
if ROOM.SILENCE in entity.location.flags:
entity.send_output(
"Il silenzio del luogo ti blocca la gola impedendoti di %s." %
channel)
return False
# (TT) Se nella stanza c'è molto casino, tante persone etc etc è difficile
# parlare piano
if entity.location.mod_noise > 75 and channel <= CHANNEL.SAY:
entity.send_output("Non puoi %s con tutta questa confusione!" %
channel)
return False
# Invia l'appropriato messaggio nel caso in cui trovi argument vuoto
if not argument:
send_not_argument_message(entity, objective, channel)
return False
# Cerca eventuali smiles nella stringa controllando gli ultimi caratteri
for social in database["socials"].itervalues():
if not social.smiles:
continue
for single_smile in social.smiles.split():
if single_smile in argument[-config.chars_for_smile:]:
break
else:
# Se non trova nessun smile esce dal ciclo dei social e continua
# col prossimo set di smiles trovato
continue
cut_smile = argument.rfind(single_smile)
# Se argument è formato solo dallo smile invia il corrispondente social
if cut_smile == 0:
social_name = social.fun_name[len("social_"):]
if objective == OBJECTIVE_TARGET:
input_to_send = "%s %s" % (social_name, target.name)
elif objective == OBJECTIVE_SELF:
input_to_send = "%s %s" % (social_name, entity.name)
else:
input_to_send = social_name
send_input(entity,
input_to_send,
"en",
show_input=False,
show_prompt=False)
return True
# Altrimenti ne ricava l'espressione dello smile-social e toglie lo
# smile da argument, se il carattere dopo lo smile era un simbolo di
# punteggiatura lo attacca alla frase togliendo gli spazi
first_part = argument[:cut_smile]
second_part = argument[cut_smile + len(single_smile):]
if second_part.strip() and second_part.strip()[0] in "!?.,:;":
first_part = first_part.rstrip()
second_part = second_part.lstrip()
argument = first_part.rstrip() + second_part.rstrip()
smile = " %s" % social.expression
break
# Elabora i punti esclamativi e interrogativi per il canale say.
# Qui viene utilizzata l'opzione chars_for_smile visto che si sta facendo
# una cosa simile a sopra, ovvero considerare solo l'ultima parte
# dell'argomento passato.
exclamations = argument[-config.chars_for_smile:].count("!")
questions = argument[-config.chars_for_smile:].count("?")
if exclamations > questions:
if channel == CHANNEL.SAY:
verb_you = "Esclami"
verb_it = " esclama"
exclaim = True
elif exclamations < questions:
if channel == CHANNEL.SAY:
verb_you = "Domandi"
verb_it = " domanda"
ask = True
# Questo elif sottintende che exclamations e questions siano uguali
elif exclamations != 0 and questions != 0:
# Con una stessa quantità di ! e di ? l'ultimo che viene trovato
# ha maggiore peso rispetto all'altro
exclamation_pos = argument.rfind("!")
question_pos = argument.rfind("?")
if exclamation_pos > question_pos:
if channel == CHANNEL.SAY:
verb_you = "Esclami"
verb_it = " esclama"
exclaim = True
else:
if channel == CHANNEL.SAY:
verb_you = "Domandi"
verb_it = " domanda"
ask = True
# Supporto per piccoli emote separati da * ad inizio argument
if argument[0] == "*":
cut_emote = argument[1:].find("*")
if cut_emote != -1:
emote = " %s" % argument[1:cut_emote + 1].strip()
if smile:
emote = " e%s" % emote
argument = argument[cut_emote + 2:].strip()
# Unisce i vari pezzi per formare l'output
expres_entity = verb_you
expres_room = verb_it
expres_target = ""
if objective == OBJECTIVE_TARGET:
name = target.get_name(entity)
expres_entity += " a %s" % name
expres_room += " a %s" % name
expres_target += " ti%s" % verb_it
elif objective == OBJECTIVE_SELF:
expres_entity += " a te stess%s" % grammar_gender(entity)
expres_room += " a sé stess%s" % grammar_gender(entity)
elif objective == OBJECTIVE_GROUP:
members = entity.get_members_here(entity.location)
if len(members) == 1:
expres_entity += " a %s" % members[0].name
expres_room += " a %s" % members[0].name
expres_target += " ti%s" % verb_it
else:
if len(members) > 5:
many = "folto "
else:
many = ""
expres_entity += " al gruppo"
expres_room += " ad un %sgruppo" % many
expres_target += "%s al gruppo" % verb_it
# Aggiunge le eventuali espressioni dello smile e dell'emote
expres_entity += smile + emote
expres_room += smile + emote
expres_target += smile + emote
if not argument:
send_not_argument_message(entity, objective, channel)
return False
# Prepara il pezzo riguardante la lingua utilizzata
language = ""
if not entity.IS_ITEM and entity.speaking != LANGUAGE.COMMON:
language = " in lingua %s" % entity.speaking
# Mischia il testo se si è ubriachi
original_argument = argument = color_first_upper(argument)
argument = drunk_speech(argument, entity)
# Parlando si impara la lingua
if not entity.IS_ITEM:
learn_language(entity, channel, entity.speaking)
# Controlla se vi sono parolacce o parole offrpg e logga i relativi argument
if entity.IS_PLAYER:
check_for_badwords(entity, argument)
# Invia il messaggio a tutti coloro che lo possono sentire
for location in expand_voice_around(entity, channel):
if not location:
log.bug(
"location per il canale %s e per l'entità %s non è valida: %r"
% (channel, entity.code, location))
continue
for listener in location.iter_contains(use_reversed=True):
if listener.position <= POSITION.SLEEP:
continue
if listener == entity:
force_return = check_trigger(entity, "before_rpg_channel",
listener, entity, target,
argument, ask, exclaim,
behavioured)
if force_return:
continue
force_return = check_trigger(
entity, "before_" + channel.trigger_suffix, listener,
entity, target, argument, ask, exclaim, behavioured)
if force_return:
continue
# Invia all'entità il suo stesso messaggio
first_part = (close_color(color) + expres_entity).rstrip()
message = "%s: '%s'" % (first_part, close_color(argument))
send_channel_message(entity, message, True)
force_return = check_trigger(entity, "after_rpg_channel",
listener, entity, target,
argument, ask, exclaim,
behavioured)
if force_return:
continue
force_return = check_trigger(entity,
"after_" + channel.trigger_suffix,
listener, entity, target,
argument, ask, exclaim,
behavioured)
if force_return:
continue
else:
# Fa ascoltare solo ad un'entità di un eventuale gruppo fisico
listener = listener.split_entity(1)
force_return = check_trigger(listener,
"before_listen_rpg_channel",
listener, entity, target,
argument, ask, exclaim,
behavioured)
if force_return:
continue
force_return = check_trigger(
listener, "before_listen_" + channel.trigger_suffix,
listener, entity, target, argument, ask, exclaim,
behavioured)
if force_return:
continue
# Prepara alcune cose a seconda della stanza di provenienza del messaggio
if entity.location == listener.location:
entity_name = entity.get_name(listener)
entity_name = color_first_upper(entity_name)
from_direction = ""
elif entity.location.IS_ROOM:
# (TD) invia qualcuno a meno che non lo si abbia conosciuto
# precedentemente con il sistema di presentazione
entity_name = "Qualcuno"
from_direction = get_from_direction(
listener.location.x, listener.location.y,
listener.location.z, entity.location.x,
entity.location.y, entity.location.z)
elif entity.location.IS_ACTOR:
if entity.location != listener:
entity_name = "Qualcuno" # (TD) come sopra
from_direction = " dall'inventario di %s" % entity.location.get_name(
listener)
else:
entity_name = "Qualcuno" # (TD) come sopra
from_direction = " da dentro %s" % entity.location.get_name(
listener)
# Prepara la prima parte, quella senza il messaggio
if objective == OBJECTIVE_ROOM:
output = "%s%s%s%s" % (entity_name,
close_color(color) + expres_room,
language, from_direction)
elif objective == OBJECTIVE_TARGET or OBJECTIVE_SELF:
if listener == target:
output = "%s%s%s%s" % (
entity_name, close_color(color) + expres_target,
language, from_direction)
else:
output = "%s%s%s%s" % (
entity_name, close_color(color) + expres_room,
language, from_direction)
elif objective == OBJECTIVE_GROUP:
if listener in group_members:
output = "%s%s%s%s" % (
entity_name, close_color(color) + expres_target,
language, from_direction)
else:
output = "%s%s%s%s" % (
entity_name, close_color(color) + expres_room,
language, from_direction)
output = "<br>%s: '%s'" % (close_color(output).rstrip(),
close_color(argument))
send_channel_message(listener, output, False)
listener.send_prompt()
force_return = check_trigger(listener,
"after_listen_rpg_channel",
listener, entity, target,
argument, ask, exclaim,
behavioured)
if force_return:
continue
force_return = check_trigger(
listener, "after_listen_" + channel.trigger_suffix,
listener, entity, target, argument, ask, exclaim,
behavioured)
if force_return:
continue
return True
def command_repaint(entity, argument=""):
"""
Permette di modificare la short, nome e descrizione di una stanza.
"""
if not entity:
log.bug("entity non è un parametro valido: %r" % entity)
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
if not argument:
syntax = get_command_syntax(entity, "command_repaint")
entity.send_output(syntax)
output = "[white]%s[close]:\n" % room.code
output += '''<table class='mud'>'''
output += '''<tr><td>Name:</td><td>%s</td></tr>''' % room.name
if room.short:
output += '''<tr><td>Short:</td><td>%s</td></tr>''' % room.short
if room.short_night:
output += '''<tr><td>ShortNight:</td><td>%s</td></tr>''' % room.short_night
output += '''<tr><td valign="top">Descr:</td><td>%s</td></tr>''' % room.descr
if room.descr_night:
output += '''<tr><td valign="top">DescrNight:</td><td>%s</td></tr>''' % room.descr_night
if room.descr_hearing:
output += '''<tr><td valign="top">DescrHearing:</td><td>%s</td></tr>''' % room.descr_hearing
if room.descr_hearing_night:
output += '''<tr><td valign="top">DescrHearingNight:</td><td>%s</td></tr>''' % room.descr_hearing_night
if room.descr_smell:
output += '''<tr><td valign="top">DescrSmell:</td><td>%s</td></tr>''' % room.descr_smell
if room.descr_smell_night:
output += '''<tr><td valign="top">DescrSmellNight:</td><td>%s</td></tr>''' % room.descr_smell_night
if room.descr_touch:
output += '''<tr><td valign="top">DescrTouch:</td><td>%s</td></tr>''' % room.descr_touch
if room.descr_touch_night:
output += '''<tr><td valign="top">DescrTouchNight:</td><td>%s</td></tr>''' % room.descr_touch_night
if room.descr_taste:
output += '''<tr><td valign="top">DescrTaste:</td><td>%s</td></tr>''' % room.descr_taste
if room.descr_taste_night:
output += '''<tr><td valign="top">DescrTasteNight:</td><td>%s</td></tr>''' % room.descr_taste_night
if room.descr_sixth:
output += '''<tr><td valign="top">DescrSixth:</td><td>%s</td></tr>''' % room.descr_sixth
if room.descr_sixth_night:
output += '''<tr><td valign="top">DescrSixthNight:</td><td>%s</td></tr>''' % room.descr_sixth_night
output += '''</table>'''
entity.send_output(output, break_line=False)
return False
arg1, argument = one_argument(argument)
attribute = ""
if is_prefix(arg1, ("name", "nome")):
attribute = "name"
attr_descr = "il nome"
elif is_prefix(arg1, ("short", "corta")):
attribute = "short"
attr_descr = "la short"
elif is_prefix(arg1,
("ShortNight", "short_night", "CortaNotte", "corta_notte")):
attribute = "short_night"
attr_descr = "la short notturna"
elif is_prefix(arg1, ("Descr", "descr", "Descrizione", "description")):
attribute = "descr"
attr_descr = "la descrizione"
elif is_prefix(arg1, ("DescrNight", "descr_night")):
attribute = "descr_night"
attr_descr = "la descrizione notturna"
elif is_prefix(arg1, ("DescrHearing", "descr_hearing")):
attribute = "descr_hearing"
attr_descr = "la descrizione uditiva"
elif is_prefix(arg1, ("DescrHearingNight", "descr_hearing_night")):
attribute = "descr_hearing_night"
attr_descr = "la descrizione uditiva notturna"
elif is_prefix(arg1, ("DescrSmell", "descr_smell")):
attribute = "descr_smell"
attr_descr = "la descrizione olfattiva"
elif is_prefix(arg1, ("DescrSmellNight", "descr_smell_night")):
attribute = "descr_smell_night"
attr_descr = "la descrizione olfattiva notturna"
elif is_prefix(arg1, ("DescrTouch", "descr_touch")):
attribute = "descr_touch"
attr_descr = "la descrizione tattile"
elif is_prefix(arg1, ("DescrTouchNight", "descr_touch_night")):
attribute = "descr_touch_night"
attr_descr = "la descrizione tattile notturna"
elif is_prefix(arg1, ("DescrTaste", "descr_taste")):
attribute = "descr_taste"
attr_descr = "la descrizione gustativa"
elif is_prefix(arg1, ("DescrTasteNight", "descr_taste_night")):
attribute = "descr_taste_night"
attr_descr = "la descrizione gustativa notturna"
elif is_prefix(arg1, ("DescrSixth", "descr_sixth")):
attribute = "descr_sixth"
attr_descr = "la descrizione intuitiva"
elif is_prefix(arg1, ("DescrSixthNight", "descr_sixth_night")):
attribute = "descr_sixth_night"
attr_descr = "la descrizione intuitiva notturna"
if not attribute:
syntax = "L'etichetta da modificare all'entità '%s' è errata: %s" % (
room.code, arg1)
syntax += get_command_syntax(entity, "command_repaint")
entity.send_output(syntax, break_line=False)
return False
if not argument:
syntax = "Il testo da sostituire nell'etichetta è vuoto."
syntax += get_command_syntax(entity, "command_repaint")
entity.send_output(syntax, break_line=False)
return False
if not check_colors(argument):
entity.send_output("Errore nella colorazione del testo: %s" % argument)
return False
if getattr(room, attribute) == argument:
entity.send_output(
"Inutile modificare %s di '%s' con un'altra stringa uguale." %
(attr_descr, room.code))
return False
setattr(room, attribute, argument)
entity.send_output(
"Hai modificato il testo dell'etichetta %s di '%s' in %s" %
(to_capitalized_words(attribute), room.code, argument))
return True
def command_tell(entity, argument=""):
"""
Permette di parlare con tutti nel Mud, in maniera off-gdr.
"""
if not entity:
log.bug("entity non è un parametro valido: %r" % entity)
return False
# -------------------------------------------------------------------------
if not argument:
entity.send_output("Vuoi %s a qualcuno che cosa?" % CHANNEL.TELL)
if entity.IS_PLAYER and OPTION.NEWBIE in entity.account.options:
syntax = get_command_syntax(entity, "command_tell")
entity.send_output(syntax, break_line=False)
return False
# Qui per la ricerca di target non viene utilizzata la find_entity perché
# deve cercare solo i giocatori online
# (TD) oltre alla ricerca di admin che possiedono mob o oggetti
arg, argument = one_argument(argument)
target = search_for_player(entity, arg)
if not target:
# (TD) se non è stato tovato allora cerca tra gli identificativi
# personali relativi ai personaggi invisibili (implementazione
# alternativa del reply)
entity.send_output(
"Non è stato trovato nessun giocatore con argomento [white]%s[close]"
% arg)
return False
# (TD) possibile implementazione di NOTELL, anche se è preferibile punizione
# classica di NO_ENTER_IN_GAME per tot giorni
if entity == target:
entity.send_output("Non puoi comunicare con [white]te stess$o[close]!")
return False
if not target.game_request:
entity.send_output(
"Il giocatore [white]%s[close] è attualmente [darkslategray]offline[close]."
% target.name)
return False
if not argument:
entity.send_output(
"Che messaggio privato vorresti inviare a [white]%s[close]?" %
target.name)
return False
channel_color = get_first_color(str(CHANNEL.TELL))
afk_status = ""
if FLAG.AFK in target.flags:
if entity.account and OPTION.ITALIAN in entity.account.options:
afk_status = " (LDT)"
else:
afk_status = " (AFK)"
if is_vowel(remove_colors(target.name)[0]):
preposition = "ad"
else:
preposition = "a"
entity.send_output("%s %s%s[close] %s: %s'%s'" %
(CHANNEL.TELL.verb_you, channel_color, preposition,
target.name, afk_status, argument),
avoid_snoop=True)
# (TD) inviare anche il soft beep per avvertire che ha ricevuto un messaggio
# ed aggiungere l'opzione apposita
if target.get_conn().get_browser():
numbered_keyword = entity.get_numbered_keyword(looker=target)
javascript = '''javascript:putInput('%s %s ');''' % (translate_input(
target, "tell", "en"), numbered_keyword)
target.send_output("""\n<a href="%s">%s%s ti[close]%s</a>: '%s'""" %
(javascript, entity.name, channel_color,
CHANNEL.TELL.verb_it, argument),
avoid_snoop=True)
else:
target.send_output(
"""\n%s %sti[close]%s: '%s'""" %
(entity.name, channel_color, CHANNEL.TELL.verb_it, argument),
avoid_snoop=True)
target.send_prompt()
return True
def command_sell(entity, argument="", verbs=VERBS, behavioured=False):
"""
Permette di vendere entità ai commercianti.
"""
# È possibile se il comando è stato deferrato
if not entity:
return False
entity = entity.split_entity(1)
if not argument:
for dealer in entity.location.iter_contains():
if dealer.shop and SHOP.DISPENSER in dealer.shop.types:
entity.act("Cerchi di %s qualcosa a $N ma ciò non è possibile perché quest'ultim$O è un distributore." % verbs["infinitive"], TO.ENTITY, dealer)
entity.act("$n cerca di %s qualcosa a $N ma ciò non è possibile perché quest'ultim$O è un distributore." % verbs["infinitive"], TO.OTHERS, dealer)
entity.act("$n cerca di %s qualcosa ma ciò non è possibile perché sei un distributore." % verbs["you2"], TO.TARGET, dealer, target)
return False
entity.send_output("Cosa vorresti %s?" % verbs["infinitive"])
if entity.IS_PLAYER and OPTION.NEWBIE in entity.account.options:
syntax = get_command_syntax(entity, "command_sell")
entity.send_output(syntax, break_line=False)
return False
# Ricava la quantità da vendere e poi l'eventuale valore facoltativo del negoziante
quantity, argument = quantity_argument(argument)
arg, argument = one_argument(argument)
target = entity.find_entity(arg, quantity=quantity, location=entity)
if not target:
entity.act("Non trovi nessun [white]%s[close] da %s nel tuo inventario." % (arg, verbs["infinitive"]), TO.ENTITY)
entity.act("$n sta cercando qualcosa senza trovarla", TO.OTHERS)
return False
# Controlla se la quantità da vendere sia sufficente rispetto a quello che si possiede
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 argument:
dealer = entity.find_entity_extensively(argument)
if not dealer:
entity.act("Non trovi nessun negoziante chiamato [white]%s[close] a cui %s $N." % (argument, verbs["infinitive"]), TO.ENTITY, target)
entity.act("$n sembra cercare qualcuno a cui %s $N." % verbs["infinitive"], TO.OTHERS, target)
return False
if not dealer.shop:
entity.act("$N non sembra essere un negoziante a cui %s $a." % verbs["infinitive"], TO.ENTITY, dealer, target)
entity.act("$n si accorge che $N non sembra essere un negoziante a cui %s $a." % verbs["infinitive"], TO.OTHERS, dealer, target)
entity.act("$n si accorge che tu non sei un negoziante a cui %s $a." % verbs["infinitive"], TO.TARGET, dealer, target)
return False
else:
for dealer in entity.location.iter_contains():
if dealer.shop:
break
else:
entity.act("Qui non trovi nessun negoziante a cui %s $N." % verbs["infinitive"], TO.ENTITY, target)
entity.act("$n non sembra trovare qualcuno a cui %s $N." % verbs["infinitive"], TO.OTHERS, target)
return False
# Controlla se il negoziante si trova in una locazione che fa, per lui, da negozio
if not dealer.shop.in_location(dealer):
entity.act("Non puoi %s nulla da $N se non si trova nel suo negozio." % verbs["infinitive"], TO.ENTITY, dealer)
entity.act("$n non può %s nulla da $N se non si trova nel suo negozio." % verbs["infinitive"], TO.OTHERS, dealer)
entity.act("$n non può %s nulla da te se non ti trovi nel tuo negozio." % verbs["infinitive"], TO.TARGET, dealer)
return False
# Indica che un'entità vuole interagire con il dealer
if entity not in dealer.interactions:
dealer.interactions.append(entity)
if FLAG.NO_DROP in target.flags:
if entity.trust > TRUST.MASTER:
entity.send_output("{Questa sarebbe in realtà un'entità NO_DROP e potresti venderla}")
else:
entity.act("Appena cerchi di %s $a a $N te lo ritrovi, con un balzo, in $hand." % verbs["infinitive"], TO.ENTITY, target, dealer)
entity.act("Appena $n cerca di %s $a a $N se lo ritrova, con un balzo, in $hand." % verbs["infinitive"], TO.OTHERS, target, dealer)
entity.act("Appena $n cerca di %s a $a gli ritorni in $hand con un balzo." % verbs["you2"], TO.TARGET, target, dealer)
entity.act("Appena $n cerca di %s $a questi gli ritorna in $hand con un balzo." % verbs["you2"], TO.TARGET, dealer, target)
return False
if not target.is_empty():
entity.act("Non puoi %s $N a $a perché contiene qualcosa." % verbs["infinitive"], TO.ENTITY, target, dealer)
entity.act("$n non può %s $N a $a perché contiene qualcosa." % verbs["infinitive"], TO.OTHERS, target, dealer)
entity.act("$n non può %s a $a perché contieni qualcosa." % verbs["you2"], TO.TARGET, target, dealer)
entity.act("$n non può %s $a perché contiene qualcosa." % verbs["you2"], TO.TARGET, dealer, target)
return False
if SHOP.DISPENSER in dealer.shop.types:
entity.act("Cerchi di %s $a a $N ma ciò non è possibile perché quest'ultim$O è un distributore." % verbs["infinitive"], TO.ENTITY, dealer, target)
entity.act("$n cerca di %s $a a $N ma ciò non è possibile perché quest'ultim$O è un distributore." % verbs["infinitive"], TO.OTHERS, dealer, target)
entity.act("$n cerca di %s $a ma ciò non è possibile perché sei un distributore." % verbs["you2"], TO.TARGET, dealer, target)
entity.act("$n cerca di %s a $N ma ciò non è possibile perché è un distributore." % verbs["you2"], TO.TARGET, target, dealer)
return False
sellable = dealer.shop.get_sellable(target)
if not sellable:
dealer.shop.send_uninterested_messages(entity, target, dealer)
return False
if target.value <= 0:
entity.act("$N guarda senza molto interesse $a: è senza valore!", TO.ENTITY, dealer, target)
entity.act("$N guarda senza molto interesse $a mostrato da $n: è senza valore.", TO.OTHERS, dealer, target)
entity.act("Guardi senza molto interesse $a mostrato da $n: è senza valore...", TO.TARGET, dealer, target)
entity.act("$a ti guarda senza molto interesse: sei senza valore...", TO.TARGET, target, dealer)
return False
# I negozianti ora pagano con denaro virtuale, in questa maniera non devono averne apposta addosso
#if not can_afford(target.value * quantity, dealer):
# entity.act("$a vale più di quanto $N possa permettersi di pagarti.", TO.ENTITY, dealer, target)
# entity.act("$a vale più di quanto $N possa permettersi di pagare $n.", TO.OTHERS, dealer, target)
# entity.act("$a vale più di quanto tu possa permetterti di pagare $n.", TO.TARGET, dealer, target)
# entity.act("Vale più di quanto $N possa permettersi di pagare $n.", TO.TARGET, target, dealer)
# return False
storage = dealer.shop.get_storage(dealer)
if not storage:
if dealer.shop.proto_storages and dealer.shop.proto_storages[0].IS_MOB:
from_where = "a chi dare"
else:
from_where = "ove mettere"
entity.act("Non puoi %s nulla a $N perché non ha %s la mercanzia!" % (verbs["infinitive"], from_where), TO.ENTITY, dealer)
entity.act("$n non può %s nulla a $N perché non ha %s la mercanzia!" % (verbs["infinitive"], from_where), TO.OTHERS, dealer)
entity.act("$n non può %s nulla perché non hai %s la mercanzia!" % (verbs["you2"], from_where), TO.TARGET, dealer)
return False
# Attenzione che qui target non è ancora la quantità giusta
force_return = check_trigger(entity, "before_sell", entity, dealer, target, quantity, behavioured)
if force_return:
return True
force_return = check_trigger(dealer, "before_selling", entity, dealer, target, quantity, behavioured)
if force_return:
return True
force_return = check_trigger(target, "before_sold", entity, dealer, target, quantity, behavioured)
if force_return:
return True
price = math.trunc((target.value * sellable.percent) / 100) * quantity
pretty_price = pretty_money_value(price, extended=True)
dealer.shop.send_sell_messages(entity, target, dealer, verbs, quantity, pretty_price)
dealer.shop.add_buyable(dealer, target, sellable, quantity)
target = target.from_location(quantity)
target.to_location(storage)
give_moneys(dealer, entity, price)
# Dona un po' di esperienza ai giocatori che hanno venduto per la prima
# volta l'entità
if entity.IS_PLAYER:
if target.prototype.code in entity.selled_entities:
entity.selled_entities[target.prototype.code] += 1
else:
entity.selled_entities[target.prototype.code] = 1
reason = "per aver venduto per la prima volta %s" % target.get_name(looker=entity)
entity.give_experience(target.level*10, reason=reason)
force_return = check_trigger(entity, "after_sell", entity, dealer, target, quantity, behavioured)
if force_return:
return True
force_return = check_trigger(dealer, "after_selling", entity, dealer, target, quantity, behavioured)
if force_return:
return True
force_return = check_trigger(target, "after_sold", entity, dealer, target, quantity, behavioured)
if force_return:
return True
return True
def command_get(entity, argument="", verbs=VERBS, behavioured=False):
# È possibile se il comando è stato deferrato
if not entity:
return False
entity = entity.split_entity(1)
# (TD) Fare altrimenti il passaggio d'argomento verboso per il get e take,
# creando il command_take?
if entity.sended_inputs and is_prefix("racco", entity.sended_inputs[-1]):
verbs = VERBS2
if not argument:
entity.send_output("Che cosa vorresti %s?" % verbs["infinitive"])
if entity.IS_PLAYER and OPTION.NEWBIE in entity.account.options:
syntax = get_command_syntax(entity, "command_get")
entity.send_output(syntax, break_line=False)
return False
original_argument = argument
# Ricava l'eventuale quantità d'oggetti da raccogliere
quantity, argument = quantity_argument(argument)
arg1, argument = one_argument(argument)
# (TD) Controllo sul mental state dell'entità
# Rimuove l'eventuali parole opzionali
from_descr = ""
if argument and is_prefix(argument, ("da ", "from ")):
from_descr = "da"
dummy_arg2, argument = one_argument(argument)
if argument:
location = entity.find_entity_extensively(argument, quantity=quantity)
# (TD) sperimentale, utilizzarlo in altri comandi se va bene
# Qui si cerca di risolvere il parsing di un eventuale argomento di
# questo tipo: prendi camicia a tunica cassa
if not location:
arg1, argument = reverse_one_argument(original_argument)
if is_number(arg1):
quantity = int(arg1)
arg1, argument = one_argument(argument)
location = entity.find_entity_extensively(argument, quantity=quantity)
if not from_descr:
from_descr = "su" # (bb)
else:
location = entity.location
if entity.location.IS_ROOM:
if not from_descr:
from_descr = "in"
else:
if not from_descr:
from_descr = "da"
if not location or (location.is_secret_door() and argument and len(argument) < config.min_secret_arg_len):
entity.act("Non riesci a trovare nessun [white]%s[close] da cui %s [white]%s[close]." % (argument, verbs["infinitive"], arg1), TO.ENTITY)
entity.act("$n sta cercando di %s qualcosa dentro qualcos'altro, ma senza molto successo." % verbs["infinitive"], TO.OTHERS)
return False
if not location.IS_ROOM and location.container_type and CONTAINER.CLOSED in location.container_type.flags:
execution_result = False
if entity.IS_PLAYER and entity.account and OPTION.AUTO_OPEN in entity.account.options:
execution_result = command_open(entity, location.get_numbered_keyword(looker=entity))
if not execution_result:
entity.act("Cerchi di %s %s da $N ma l$O trovi chius$O." % (verbs["infinitive"], arg1), TO.ENTITY, location)
entity.act("$n cerca di %s %s da $N ma l$O trova chius$O." % (verbs["infinitive"], arg1), TO.OTHERS, location)
entity.act("$n cerca di %s %s ma ti trova chius$O." % (verbs["you2"], arg1), TO.TARGET, location)
return False
if argument:
avoid_equipment = True
if location.IS_ITEM:
avoid_equipment = False
target = entity.find_entity(arg1, location=location, avoid_equipment=avoid_equipment)
else:
target = entity.find_entity_extensively(arg1, inventory_pos="last")
if ((location.IS_ACTOR and not location.container_type and entity.location != location)
or (not target and location.IS_ITEM and not location.container_type)
or (target and location.IS_ITEM and not location.container_type and len(target.wear_mode) <= 0)):
if entity.trust > TRUST.PLAYER:
entity.send_to_admin("Anche se non è un contenitore lo puoi manipolare comunque")
else:
entity.act("Non riesci a %s %s da $N." % (verbs["infinitive"], arg1), TO.ENTITY, location)
entity.act("Non riesce a %s nulla da $N." % verbs["infinitive"], TO.OTHERS, location)
entity.act("Non riesce a %s nulla da te." % verbs["infinitive"], TO.TARGET, location)
return False
if not target or (target.is_secret_door() and len(arg1) < config.min_secret_arg_len):
if location.IS_ROOM:
entity.act("Non riesci a trovare nessun [white]%s[close] da %s." % (arg1, verbs["infinitive"]), TO.ENTITY)
entity.act("$n sta cercando qualcosa, ma senza molto successo.", TO.OTHERS)
else:
entity.act("Non riesci a trovare nessun [white]%s[close] da %s %s $N." % (arg1, verbs["infinitive"], from_descr), TO.ENTITY, location)
entity.act("$n sta cercando qualcosa dentro $N, ma senza molto successo.", TO.OTHERS, location)
return False
if quantity == 0:
quantity = target.quantity
elif target.quantity < quantity:
entity.act("Non puoi %s $N perché ve ne sono 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
# Di default si raccoglie da terra
if not location:
location = entity.location
force_return = check_trigger(target, "before_try_to_get", entity, target, location, behavioured)
if force_return:
return True
if target == entity:
entity.act("Cerchi di %s da sol$o... impossibile!" % verbs["you2"], TO.ENTITY)
entity.act("$n cerca di %s da sol$o... sarà dura che ce la faccia!" % verbs["self"], TO.OTHERS)
return False
if target.location == entity:
entity.act("Cerchi di %s $N ma ti accorgi di averl$O già con te." % verbs["infinitive"], TO.ENTITY, target)
entity.act("$n cerca di %s $N ma si accorge di averl$O già con sé." % verbs["infinitive"], TO.OTHERS, target)
return False
# Controlla che il peso ((TD) e lo spazio) attualmente trasportato dall'entità
# permetta o meno il get
# (TD) il bard aveva anche il can_carry_number
if not entity.can_carry_target(target, quantity=quantity):
if entity.trust > TRUST.PLAYER:
entity.send_to_admin("Riesci comunque a %s %s anche se è troppo pesante per te." % (
verbs["infinitive"], target.get_name(entity)))
else:
entity.act("Non puoi %s $N, non riesci a portare con te tutto quel peso." % verbs["infinitive"], TO.ENTITY, target)
entity.act("$n non può %s $N, non riesce a portare con sé tutto quel peso." % verbs["infinitive"], TO.OTHERS, target)
entity.act("$n non può %s, non riesce a portare con sé tutto il tuo peso." % verbs["you2"], TO.TARGET, target)
return False
# Evita di far rubare a meno che non ci si trovi proprio nell'inventario della vittima
if location.IS_PLAYER and location != entity.location:
if entity.trust > TRUST.PLAYER:
entity.send_to_admin("Raccogli da un giocatore anche se non potresti")
else:
entity.act("Cerchi di %s qualcosa da $a, ma ti fermi prima di compiere un [gray]furto[close]." % verbs["infinitive"], TO.ENTITY, target, location)
entity.act("$n cerca di %s qualcosa da $N, tuttavia si ferma prima di compiere un [gray]furto[close]." % verbs["infinitive"], TO.OTHERS, location)
entity.act("\n$n cerca di %s qualcosa da $a, ma si ferma prima di compiere un [gray]furto[close]." % verbs["you2"], TO.TARGET, target, location)
entity.act("\n$n cerca di %s qualcosa, tuttavia si ferma prima di compiere un [gray]furto[close]." % verbs["you2"], TO.TARGET, location, target)
return False
# Se non è passato del tempo il cadavere non è lootabile
if target.corpse_type and target.corpse_type.was_player and target.corpse_type.decomposition_rpg_hours <= len(CORPSE_DESCRS):
if entity.trust > TRUST.PLAYER:
entity.send_to_admin("Raccogli da un cadavere di giocatore anche se non potresti")
else:
entity.act("Cerchi di %s qualcosa da $a, ma ti fermi prima di compiere un [gray]furto[close]." % verbs["infinitive"], TO.ENTITY, target, location)
entity.act("$n cerca di %s qualcosa da $N, tuttavia si ferma prima di compiere un [gray]furto[close]." % verbs["infinitive"], TO.OTHERS, location)
entity.act("\n$n cerca di %s qualcosa da $a, ma si ferma prima di compiere un [gray]furto[close]." % verbs["you2"], TO.TARGET, target, location)
entity.act("\n$n cerca di %s qualcosa, tuttavia si ferma prima di compiere un [gray]furto[close]." % verbs["you2"], TO.TARGET, location, target)
return False
if FLAG.NO_GET in target.flags:
if entity.trust > TRUST.PLAYER:
entity.send_to_admin("Raccogli l'oggetto anche se è NO_GET")
else:
entity.act("Cerchi di $a $N... ma [darkgray]senza successo[close].", TO.ENTITY, target, verbs["infinitive"])
entity.act("$n cerca di $a $N... [darkgray]senza successo[close].", TO.OTHERS, target, verbs["infinitive"])
entity.act("$n cerca di $a... [darkgray]senza successo[close].", TO.TARGET, target, verbs["you2"])
if not location.IS_ROOM:
entity.act("$n cerca di $a $N da te... [darkgray]senza successo[close].", TO.TARGET, target, verbs["infinitive"])
return False
if location.IS_ROOM and ROOM.NO_GET in location.flags:
if entity.trust > TRUST.PLAYER:
entity.send_to_admin("Raccogli l'oggetto anche se la stanza è NO_GET")
else:
entity.act("Cerchi di %s $N, tuttavia una [royalblue]forza misteriosa[close] del luogo respinge la tua $hand." % verbs["infinitive"], TO.ENTITY, target)
entity.act("$n cerca di %s $N, tuttavia una [royalblue]forza misteriosa[close] del luogo sembra respingere la sua $hand." % verbs["infinitive"], TO.OTHERS, target)
entity.act("\n$n cerca di %s, tuttavia una [royalblue]forza misteriosa[close] del luogo sembra respingere la sua $hand." % verbs["you2"], TO.TARGET, target)
return False
if not location.IS_ROOM and location == entity.location and len(target.wear_mode) > 0:
entity.act("Stai per %s $N svestendo $a, ma poi ti fermi, non è proprio il caso." % verbs["infinitive"], TO.ENTITY, target, location)
entity.act("$ sembra voler %s $N svestendo $a, ma poi si ferma." % verbs["infinitive"], TO.OTHERS, target, location)
entity.act("$n sembra voler %s $N da te, ma poi si ferma." % verbs["infinitive"], TO.TARGET, target, location)
return False
if FLAG.BURIED in target.flags:
if entity.trust > TRUST.PLAYER:
entity.send_to_admin("Raccogli l'oggetto anche se è BURIED rimuovendo tale flag")
else:
log.bug("Oggetto buried gettabile da un giocatore senza trust: %s" % target.code)
return False
# Ricava l'attributo corretto
if target.IS_PLAYER:
if entity.trust > TRUST.PLAYER:
entity.send_to_admin("Raccogli il giocatore anche se non potresti")
else:
entity.act("Cerchi di %s $N, ma ti fermi per [indianred]rispetto[close] nei suoi confronti." % verbs["infinitive"], TO.ENTITY, target)
entity.act("$n cerca di %s $N, tuttavia si ferma per [indianred]rispetto[close] nei suoi confronti." % verbs["infinitive"], TO.OTHERS, target)
entity.act("\n$n cerca di %s, tuttavia si ferma per [indianred]rispetto[close] nei tuoi confronti." % verbs["you2"], TO.TARGET, target)
if not location.IS_ROOM:
entity.act("$n cerca di %s $a da te, tuttavia si ferma per [indianred]rispetto[close] nei tuoi e suoi confronti." % verbs["infinitive"], TO.TARGET, location, target)
return False
# Nel caso l'oggetto era addosso ad un altro oggetto (è meglio tenere
# queste righe di codice prima del check del trigger before_get visto
# che a volte negli script vengono modificate le flag di wear)
if len(target.wear_mode) > 0:
target.wear_mode.clear()
target.under_weared = None
# In questa maniera crea l'entità finale che verrà manipolata dai trigger
# in maniera omogenea senza dover attendere la chiamata della from_location
target = target.split_entity(quantity)
force_return = check_trigger(entity, "before_get", entity, target, location, behavioured)
if force_return:
return True
force_return = check_trigger(target, "before_getted", entity, target, location, behavioured)
if force_return:
return True
force_return = check_trigger(location, "before_get_from_location", entity, target, location, behavioured)
if force_return:
return True
if quantity <= 1:
entity.act("%s $N da $a." % color_first_upper(verbs["you"]), TO.ENTITY, target, location)
entity.act("$n %s $N da $a." % verbs["it"], TO.OTHERS, target, location)
entity.act("$n ti %s da $a." % verbs["it"], TO.TARGET, target, location)
else:
entity.act("%s $N, per una quantità di %d, da $a." % (color_first_upper(verbs["you"]), quantity), TO.ENTITY, target, location)
entity.act("$n %s $N, per una quantità di %d, da $a." % (verbs["it"], quantity), TO.OTHERS, target, location)
entity.act("$n ti %s, per una quantità di %d, da $a." % (verbs["it"], quantity), TO.TARGET, target, location)
if not location.IS_ROOM:
entity.act("$n ti %s qualcosa." % verbs["it"], TO.TARGET, location)
target = target.from_location(quantity)
target.to_location(entity)
# Nel caso sia un seme e fosse stato un admin a gettarlo:
target.flags -= FLAG.BURIED
# (TT) forse questo pezzo di codice andrebbe meglio in from_location
if target.seed_type:
target.seed_type.stop_growth()
if target.plant_type:
target.plant_type.stop_growth()
# Se il comando get è stato eseguito tramite un behaviour allora l'oggetto
# raccolto ha una probabilità di essere purificato, queste righe di codice
# devono trovarsi DOPO la chiamata alla to_location, che esegue una pulizia
# della deferred relativa alla purificazione
if behavioured:
target.start_purification(config.purification_rpg_hours)
force_return = check_trigger(entity, "after_get", entity, target, location, behavioured)
if force_return:
return True
force_return = check_trigger(target, "after_getted", entity, target, location, behavioured)
if force_return:
return True
force_return = check_trigger(location, "after_get_from_location", entity, target, location, behavioured)
if force_return:
return True
return True
def command_restring(entity, argument=""):
"""
Permette di modificare la short il nome e la descrizione dell'oggetto voluto.
"""
if not entity:
log.bug("entity non è un parametro valido: %r" % entity)
return False
# -------------------------------------------------------------------------
if not argument:
syntax = get_command_syntax(entity, "command_restring")
entity.send_output(syntax, break_line=False)
return False
arg1, argument = one_argument(argument)
target = entity.find_entity_extensively(arg1, inventory_pos="first")
if not target:
entity.send_output("Nessuna entità trovata con argomento [white]%s[close]." % arg1)
return False
if not argument:
output = "[white]%s[close]:\n" % target.code
output += '''<table class='mud'>'''
if not target.IS_PLAYER:
output += '''<tr><td>KeywordsName:</td><td>%s</td></tr>''' % target.keywords_name
output += '''<tr><td>KeywordsShort:</td><td>%s</td></tr>''' % target.keywords_short
output += '''<tr><td>KeywordsShortNight:</td><td>%s</td></tr>''' % target.keywords_short_night
output += '''<tr><td>Name:</td><td>%s</td></tr>''' % target.name
if target.short:
output += '''<tr><td>Short:</td><td>%s</td></tr>''' % target.short
if target.short_night:
output += '''<tr><td>ShortNight:</td><td>%s</td></tr>''' % target.short_night
if target.long:
output += '''<tr><td>Long:</td><td>%s</td></tr>''' % target.long
if target.long_night:
output += '''<tr><td>LongNight:</td><td>%s</td></tr>''' % target.long_night
output += '''<tr><td>Descr:</td><td>%s</td></tr>''' % target.descr
if target.descr_night:
output += '''<tr><td valign="top">DescrNight:</td><td>%s</td></tr>''' % target.descr_night
if target.descr_hearing:
output += '''<tr><td valign="top">DescrHearing:</td><td>%s</td></tr>''' % target.descr_hearing
if target.descr_hearing_night:
output += '''<tr><td valign="top">DescrHearingNight:</td><td>%s</td></tr>''' % target.descr_hearing_night
if target.descr_smell:
output += '''<tr><td valign="top">DescrSmell:</td><td>%s</td></tr>''' % target.descr_smell
if target.descr_smell_night:
output += '''<tr><td valign="top">DescrSmellNight:</td><td>%s</td></tr>''' % target.descr_smell_night
if target.descr_touch:
output += '''<tr><td valign="top">DescrTouch:</td><td>%s</td></tr>''' % target.descr_touch
if target.descr_touch_night:
output += '''<tr><td valign="top">DescrTouchNight:</td><td>%s</td></tr>''' % target.descr_touch_night
if target.descr_taste:
output += '''<tr><td valign="top">DescrTaste:</td><td>%s</td></tr>''' % target.descr_taste
if target.descr_taste_night:
output += '''<tr><td valign="top">DescrTasteNight:</td><td>%s</td></tr>''' % target.descr_taste_night
if target.descr_sixth:
output += '''<tr><td valign="top">DescrSixth:</td><td>%s</td></tr>''' % target.descr_sixth
if target.descr_sixth_night:
output += '''<tr><td valign="top">DescrSixthNight:</td><td>%s</td></tr>''' % target.descr_sixth_night
output += '''</table>'''
if target.IS_PLAYER and not target.game_request:
entity.send_output("Il giocatore %s è [darkslategray]offline[close]")
entity.send_output(output, break_line=False)
return True
arg2, argument = one_argument(argument)
attribute = ""
if is_prefix(arg2, ("KeywordsName", "keywords_name")):
attribute = "keywords_name"
attr_descr = "le parole chiavi del nome"
elif is_prefix(arg2, ("KeywordsShort", "keywords_short")):
attribute = "keywords_short"
attr_descr = "le parole chiavi della short"
elif is_prefix(arg2, ("KeywordsShortNight", "keywords_short_night")):
attribute = "keywords_short_night"
attr_descr = "le parole chiavi della short notturna"
elif is_prefix(arg2, ("Name", "nome")):
attribute = "name"
attr_descr = "il nome"
elif is_prefix(arg2, ("Short", "corta")):
attribute = "short"
attr_descr = "la short"
elif is_prefix(arg2, ("ShortNight", "short_night")):
attribute = "short_night"
attr_descr = "la short notturna"
elif is_prefix(arg2, ("Long", "lunga")):
attribute = "long"
attr_descr = "la long"
elif is_prefix(arg2, ("LongNight", "long_night")):
attribute = "long_night"
attr_descr = "la long notturna"
elif is_prefix(arg2, ("Descr", "descr", "Descrizione", "description")):
attribute = "descr"
attr_descr = "la descrizione"
elif is_prefix(arg2, ("DescrNight", "descr_night")):
attribute = "descr_night"
attr_descr = "la descrizione notturna"
elif is_prefix(arg2, ("DescrHearing", "descr_hearing")):
attribute = "descr_hearing"
attr_descr = "la descrizione uditiva"
elif is_prefix(arg2, ("DescrHearingNight", "descr_hearing_night")):
attribute = "descr_hearing_night"
attr_descr = "la descrizione uditiva notturna"
elif is_prefix(arg2, ("DescrSmell", "descr_smell")):
attribute = "descr_smell"
attr_descr = "la descrizione olfattiva"
elif is_prefix(arg2, ("DescrSmellNight", "descr_smell_night")):
attribute = "descr_smell_night"
attr_descr = "la descrizione olfattiva notturna"
elif is_prefix(arg2, ("DescrTouch", "descr_touch")):
attribute = "descr_touch"
attr_descr = "la descrizione tattile"
elif is_prefix(arg2, ("DescrTouchNight", "descr_touch_night")):
attribute = "descr_touch_night"
attr_descr = "la descrizione tattile notturna"
elif is_prefix(arg2, ("DescrTaste", "descr_taste")):
attribute = "descr_taste"
attr_descr = "la descrizione gustativa"
elif is_prefix(arg2, ("DescrTasteNight", "descr_taste_night")):
attribute = "descr_taste_night"
attr_descr = "la descrizione gustativa notturna"
elif is_prefix(arg2, ("DescrSixth", "descr_sixth")):
attribute = "descr_sixth"
attr_descr = "la descrizione intuitiva"
elif is_prefix(arg2, ("DescrSixthNight", "descr_sixth_night")):
attribute = "descr_sixth_night"
attr_descr = "la descrizione intuitiva notturna"
if not attribute:
syntax = "L'etichetta da modificare all'entità '%s' è errata: %s" % (target.code, arg2)
syntax += get_command_syntax(entity, "command_restring")
entity.send_output(syntax, break_line=False)
return False
if not argument:
syntax = "Il testo da sostituire nell'etichetta è vuoto."
syntax += get_command_syntax(entity, "command_restring")
entity.send_output(syntax, break_line=False)
return False
if not check_colors(argument):
entity.send_output("Errore nella colorazione del testo: %s" % argument)
return False
if getattr(target, attribute) == argument:
entity.send_output("Inutile modificare %s di '%s' con un'altra stringa uguale." % (attr_descr, target.code))
return False
# Se si sta rinominando un giocatore allora si tiene traccia del vecchio nome
if target.IS_PLAYER:
if attribute == "name":
argument = color_first_upper(argument)
err_msg_name = get_error_message_name(argument, True, "players")
if err_msg_name:
entity.send_output(err_msg_name)
return False
if not is_same(argument, target.name):
target.old_names += " " + target.name
# (TD) fare anche i messaggi d'avviso per gli altri attributi? da pensare
target.send_output("\nTi è stato cambiato il nome da %s a %s" % (target.name, argument))
target.send_prompt()
elif attribute in ("keywords_name", "keywords_short", "keywords_short_night"):
entity.send_output("È impossibile modificare %s nei giocatori." % attr_descr)
return False
setattr(target, attribute, argument)
entity.send_output("Hai modificato il testo dell'etichetta %s di '%s' in %s" % (
to_capitalized_words(attribute), target.code, argument))
return True
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
def command_follow(entity, argument="", verbs=VERBS, behavioured=False):
# È possibile se il comando è stato deferrato
if not entity:
return False
entity = entity.split_entity(1)
if not argument:
entity.send_output("Chi vorresti %s?" % verbs["infinitive"])
if entity.IS_PLAYER and OPTION.NEWBIE in entity.account.options:
syntax = get_command_syntax(entity, "command_follow")
entity.send_output(syntax, break_line=False)
return False
ag1, argument = one_argument(argument)
target = entity.find_entity(ag1, location=entity.location)
if not target:
entity.act("Non trovi nessun %s da %s qui attorno." % (ag1, verbs["infinitive"]), TO.ENTITY)
entity.act("$n sembra stia cercando qualcuno qui attorno che non c'è.", TO.OTHERS)
return False
# (TD) anche qui forse ci vuole lo split
pass
# Se entity è sotto charm preferisce rimanere accanto al proprio master
if entity.master:
if entity.master == SEX.FEMALE:
suffix = "alla tua maestra"
else:
suffix = "al tuo maestro"
entity.act("Preferisci rimanere accanto %s $a." % suffix, TO.ENTITY, target, entity.master)
entity.act("$n tenta di %s $N ma poi cambia idea, come ipnotizzat$o." % verbs["infinitive"], TO.OTHERS, target)
entity.act("$n tenta di %s ma poi cambia idea, come ipnotizzat$o." % verbs["you2"], TO.TARGET, target)
entity.act("$n tenta di ribellarsi %s $a, ma poi cambia idea, è ancora in mano tua." % (
verbs["gerund"], TO.TARGET, entity.master, target)) # (bb) possibile errore di doppio messaggio
return False
# Per smettere di seguire o essere seguiti basta scegliere come obiettivo
# sé stessi
if entity == target:
if entity.guide:
show_stop_following_messages(entity, target, verbs)
entity.guide = None
return True
else:
entity.act("Già non stai %s nessuno" % verbs["gerund"], TO.ENTITY)
entity.act("$n si accorge solo ora che non sta %s nessuno." % verbs["gerund"], TO.OTHERS)
return False
# Evita di farsi seguire a vicenda, sarebbe dannoso in aree maze-like
if entity.have_circle_follow(target):
entity.act("Cominci a %s $N, che però segue te! Quindi decidi di smettere di farlo." % verbs["infinitive"], TO.ENTITY, target)
entity.act("$n e $N cominciano a seguirsi a vicenda, ma smettono quando capiscono che non è una gran idea.", TO.OTHERS, target)
entity.act("$n comincia a seguirti, tuttavia tu insegui già lui! Dopo un po' decide di smettere di farlo.", TO.TARGET, target)
return False
force_return = check_trigger(entity, "before_follow", entity, target, behavioured)
if force_return:
return True
force_return = check_trigger(target, "before_followed", entity, target, behavioured)
if force_return:
return True
if entity.guide:
show_stop_following_messages(entity, target, verbs)
entity.guide = None
emote_argument = get_emote_argument(argument)
entity.act("Cominci a %s $N%s." % (verbs["infinitive"], emote_argument), TO.ENTITY, target)
if target.can_see(entity):
# (TD) è che qui più che qualcuno segue $N è proprio o vedi o non vedi,
# e non un: riconosci o non riconosci, da pensare se inserire un
# parametro in più per la act per variare un po'
entity.act("$n comincia a %s $N%s." % (verbs["infinitive"], emote_argument), TO.OTHERS, target)
entity.act("$n ti comincia a %s%s." % (verbs["infinitive"], emote_argument), TO.TARGET, target)
else:
if target.trust > TRUST.PLAYER:
target.send_to_admin("Anche se non lo puoi vedere sai che %s ha cominciato a %s." % (entity.name, verbs["you2"]))
entity.guide = target
force_return = check_trigger(entity, "after_follow", entity, target, behavioured)
if force_return:
return True
force_return = check_trigger(target, "after_followed", entity, target, behavioured)
if force_return:
return True
return True
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 command_follow(entity, argument="", verbs=VERBS, behavioured=False):
# È possibile se il comando è stato deferrato
if not entity:
return False
entity = entity.split_entity(1)
if not argument:
entity.send_output("Chi vorresti %s?" % verbs["infinitive"])
if entity.IS_PLAYER and OPTION.NEWBIE in entity.account.options:
syntax = get_command_syntax(entity, "command_follow")
entity.send_output(syntax, break_line=False)
return False
ag1, argument = one_argument(argument)
target = entity.find_entity(ag1, location=entity.location)
if not target:
entity.act(
"Non trovi nessun %s da %s qui attorno." %
(ag1, verbs["infinitive"]), TO.ENTITY)
entity.act("$n sembra stia cercando qualcuno qui attorno che non c'è.",
TO.OTHERS)
return False
# (TD) anche qui forse ci vuole lo split
pass
# Se entity è sotto charm preferisce rimanere accanto al proprio master
if entity.master:
if entity.master == SEX.FEMALE:
suffix = "alla tua maestra"
else:
suffix = "al tuo maestro"
entity.act("Preferisci rimanere accanto %s $a." % suffix, TO.ENTITY,
target, entity.master)
entity.act(
"$n tenta di %s $N ma poi cambia idea, come ipnotizzat$o." %
verbs["infinitive"], TO.OTHERS, target)
entity.act(
"$n tenta di %s ma poi cambia idea, come ipnotizzat$o." %
verbs["you2"], TO.TARGET, target)
entity.act(
"$n tenta di ribellarsi %s $a, ma poi cambia idea, è ancora in mano tua."
% (verbs["gerund"], TO.TARGET, entity.master,
target)) # (bb) possibile errore di doppio messaggio
return False
# Per smettere di seguire o essere seguiti basta scegliere come obiettivo
# sé stessi
if entity == target:
if entity.guide:
show_stop_following_messages(entity, target, verbs)
entity.guide = None
return True
else:
entity.act("Già non stai %s nessuno" % verbs["gerund"], TO.ENTITY)
entity.act(
"$n si accorge solo ora che non sta %s nessuno." %
verbs["gerund"], TO.OTHERS)
return False
# Evita di farsi seguire a vicenda, sarebbe dannoso in aree maze-like
if entity.have_circle_follow(target):
entity.act(
"Cominci a %s $N, che però segue te! Quindi decidi di smettere di farlo."
% verbs["infinitive"], TO.ENTITY, target)
entity.act(
"$n e $N cominciano a seguirsi a vicenda, ma smettono quando capiscono che non è una gran idea.",
TO.OTHERS, target)
entity.act(
"$n comincia a seguirti, tuttavia tu insegui già lui! Dopo un po' decide di smettere di farlo.",
TO.TARGET, target)
return False
force_return = check_trigger(entity, "before_follow", entity, target,
behavioured)
if force_return:
return True
force_return = check_trigger(target, "before_followed", entity, target,
behavioured)
if force_return:
return True
if entity.guide:
show_stop_following_messages(entity, target, verbs)
entity.guide = None
emote_argument = get_emote_argument(argument)
entity.act("Cominci a %s $N%s." % (verbs["infinitive"], emote_argument),
TO.ENTITY, target)
if target.can_see(entity):
# (TD) è che qui più che qualcuno segue $N è proprio o vedi o non vedi,
# e non un: riconosci o non riconosci, da pensare se inserire un
# parametro in più per la act per variare un po'
entity.act(
"$n comincia a %s $N%s." % (verbs["infinitive"], emote_argument),
TO.OTHERS, target)
entity.act(
"$n ti comincia a %s%s." % (verbs["infinitive"], emote_argument),
TO.TARGET, target)
else:
if target.trust > TRUST.PLAYER:
target.send_to_admin(
"Anche se non lo puoi vedere sai che %s ha cominciato a %s." %
(entity.name, verbs["you2"]))
entity.guide = target
force_return = check_trigger(entity, "after_follow", entity, target,
behavioured)
if force_return:
return True
force_return = check_trigger(target, "after_followed", entity, target,
behavioured)
if force_return:
return True
return True
def skill_kick(entity, argument="", verbs=VERBS, silent=False):
"""
Skill di combattimento, deve avere un target già prefissato.
Dà un calcio alla vittima con cui si combatte.
"""
if not entity:
log.bug("entity non è un parametro valido: %r" % entity)
return "failure"
# -------------------------------------------------------------------------
arg, argument = one_argument(argument)
if arg:
target = entity.find_entity_extensively(arg)
if not target:
entity.send_output("Chi vorresti %s?" % verbs["infinitive"])
return "failure"
else:
target = opponent = entity.get_opponent()
if not target:
entity.send_output("Chi vorresti %s?" % verbs["infinitive"])
return "failure"
# (TD) gestire le posizioni
if "kick" not in entity.skills:
entity.skills["kick"] = 0
skill_result = check_skill(entity, target, "kick")
print ">>>>>>> skill kick: skill_result: ", skill_result
# Ricava quale parte viene colpita
#arg, argument = one_argument(argument)
#if not arg:
# victim_part = None
# Ricava se viene utilizzata la gamba destra o sinistra
#right_leg = True
#if not argument:
# right_leg = entity.hand
#else:
# if is_same(argument, ("destro", "destra", "right")):
# right_leg = True
# elif is_same(argument, ("sinistro", "sinistra", "left")):
# right_leg = False
# else:
# entity.send_output("Vuoi calciare con la gamba destra o quella sinistra?")
# return False
force_return = check_trigger(entity, "before_kick", entity, target, skill_result)
if force_return:
return "failure"
force_return = check_trigger(target, "before_kicked", entity, target, skill_result)
if force_return:
return "failure"
if not entity.is_fighting(with_him=target):
start_fight(entity, target)
if skill_result < config.clumsy_value:
if not silent:
entity.act("Tenti di %s il colpo di $N ma metti male la caviglia ed un dolore acuto ti trafigge." % verbs["infinitive"], TO.ENTITY, target)
entity.act("$n tenta di %s il colpo di $N ma inciampa facendosi del male." % verbs["infinitive"], TO.OTHERS, target)
entity.act("$n si fa del male mentre tenta di %s d'anticipo." % verbs["you2"], TO.TARGET, target)
# (TD) l'attaccante cade
kick_damage(entity, target, "clumsy", skill_result)
execution_result = "clumsy"
entity.wait(KICK_WAIT * 2)
elif skill_result < config.failure_value:
if not silent:
entity.act("Tenti maldestramente di %s $N rischiando pure di cadere." % verbs["infinitive"], TO.ENTITY, target)
entity.act("$n tenta maldestramente di %s $N rischiando di cadere." % verbs["infinitive"], TO.OTHERS, target)
entity.act("$n tenta maldestramente di %s rischiando di cadere." % verbs["you2"], TO.TARGET, target)
kick_damage(entity, target, "failure", skill_result)
execution_result = "failure"
entity.wait(KICK_WAIT * 2)
elif skill_result < config.success_value:
if not silent:
entity.act("Riesci a prendere alla sprovvista $N e %s." % verbs["noun"], TO.ENTITY, target)
entity.act("$n riesce a prendere alla sprovvista$N e %s." % verbs["noun"], TO.OTHERS, target)
entity.act("$n ti prende alla alla sprovvista e riesce a %s."% verbs["you2"], TO.TARGET, target)
damage = kick_damage(entity, target, "success", skill_result)
execution_result = "success"
entity.wait(KICK_WAIT)
else:
if not silent:
entity.act("Riesci magistralmente a %s $N prendendol$O alla sprovvista." % verbs["infinitive"], TO.ENTITY, target)
entity.act("$n riesce magistralmente a %s $N prendendol$O alla sprovvista." % verbs["infinitive"], TO.OTHERS, target)
entity.act("$n riesce magistralmente a %s prendendoti alla sprovvista."% verbs["infinitive"], TO.TARGET, target)
# (TD) il nemico cade
kick_damage(entity, target, "masterly", skill_result)
execution_result = "masterly"
entity.wait(KICK_WAIT)
force_return = check_trigger(entity, "after_kick", entity, target, skill_result)
if force_return:
return execution_result
force_return = check_trigger(target, "after_kicked", entity, target, skill_result)
if force_return:
return execution_result
return execution_result
def skill_thundering(entity, argument="", silent=False):
"""
Skill voce tonante, prende di sorpresa il nemico urlandogli contro
qualcosa in maniera 'tonante'.
"""
if not entity:
log.bug("entity non è un parametro valido: %r" % entity)
return False
# -------------------------------------------------------------------------
execution_success = rpg_channel(entity, argument, CHANNEL.THUNDERING)
if not execution_success:
return False
# (TD) rimane così fino al rifacimento delle skill
return True
# La gestione dell'argomento vuoto viene effettuata dalla rpg_channel.
# Anche se la parte skillosa del comando non viene effettuata il comando
# è considerato eseguito
if not argument:
return True
arg, argument = one_argument(argument)
# Qui effettua una ricerca della particella in minuscolo, ci sono più
# probabilità che non conflitti con la ricerca del nome di un'entità
if argument and arg[0 : 2] == "a ":
arg, argument = one_argument(argument)
# Se il target non si trova allora esce, non eseguendo la parte della skill
# e considerando il thundering come un comando di canale rpg
target = entity.find_entity_extensively(arg)
if not target:
return True
percent = check_skill(entity, target, "thundering")
# (TD) farla utilizzare anche in combattimento, ma ad inizio combattimento
# ci sono più chance di sorpresa
if percent < config.clumsy_value:
if not silent:
entity.act("\nCerchi di prendere di [yellow]sorpresa[close] $N con la tua [red]voce tonante[close] ma tutto quello che ti esce è una [pink]vocina stridula[close]...", TO.ENTITY, target)
entity.act("$lui cerca di prendere di [yellow]sorpresa[close] $N con la sua [red]voce tonante[close] ma tutto quello che gli esce è una [pink]vocina stridula[close]...", TO.OTHERS, target)
entity.act("$lui cerca ti prenderti di [yellow]sorpresa[close] con la sua [red]voce tonante[close] ma tutto quello che gli esce è una [pink]vocina stridula[close]...", TO.TARGET, target)
return "clumsy"
elif percent < config.failure_value:
if not silent:
entity.act("\nCerchi di prendere di [yellow]sorpresa[close] $N con la tua [red]voce tonante[close] ma [dimgray]fallisci[close]...", TO.ENTITY, target)
entity.act("$lui cerca ti prenderti di [yellow]sorpresa[close] con la sua [red]voce tonante[close] ma [dimgray]fallisce[close]...", TO.OTHERS, target)
entity.act("$lui cerca di prendere di [yellow]sorpresa[close] $N con la sua [red]voce tonante[close] ma [dimgray]fallisce[close]..", TO.TARGET, target)
return "failure"
elif percent < config.success_value:
if not silent:
entity.act("\n[white]Riesci[close] a prendere di [yellow]sorpresa[close] $N con la tua [red]voce tonante[close]!", TO.ENTITY, target)
entity.act("$lui [white]riesce[close] a prendere di [yellow]sorpresa[close] $N con la sua [red]voce tonante[close]!", TO.OTHERS, target)
entity.act("$lui ti [white]riesce[close] a prendere di [yellow]sorpresa[close] con la sua [red]voce tonante[close]!", TO.TARGET, target)
return "success"
else:
if not silent:
entity.act("\n$N [cyan]salta per aria[close] dalla [yellow]sorpresa[close] e rimane [yellow]spaesato[close] dalla tua [red]voce tonante[close]!", TO.ENTITY, target)
entity.act("$N [cyan]salta per aria[close] dalla [yellow]sorpresa[close] e rimane [yellow]spaesato[close] dalla [red]voce tonante[close] di $lui!", TO.OTHERS, target)
entity.act("[cyan]Salti per aria[close] dalla [yellow]sorpresa[close] e rimani [yellow]spaesato[close] dalla [red]voce tonante[close] di $lui!", TO.TARGET, target)
# (TD) Penalità in attesa nell'iniziare il combattimento o del turno
return "masterly"
# (TD) se però non è già iniziato non ne ha bisogno (??) cusa l'è che intendevo?
#start_fight(entity, target)
return True
def seed_or_plant(entity, argument, verbs, behavioured, command_name):
if not entity:
log.bug("entity non è un parametro valido: %r" % entity)
return False
if not verbs:
log.bug("verbs non è un parametro valido: %r" % verbs)
return False
if command_name not in ("command_seed", "command_plant"):
log.bug("command_name non è un parametro valido: %r" % command_name)
return False
# -------------------------------------------------------------------------
entity = entity.split_entity(1)
gamescript_suffix = command_name.split("_")[1]
type_attr_name = gamescript_suffix + "_type"
if not argument:
entity.act("Che cosa vorresti %s?" % verbs["infinitive"], TO.ENTITY)
if entity.IS_PLAYER and OPTION.NEWBIE in entity.account.options:
syntax = get_command_syntax(entity, command_name)
entity.send_output(syntax, break_line=False)
return False
# (TD) Controllo del mental state deviato
# Ricerca le entità da seminare o piantare nell'inventario
arg1, argument = one_argument(argument)
target = entity.find_entity(arg1, location=entity)
if not target:
entity.act("Non hai nessun [white]%s[close] da %s." % (arg1, verbs["infinitive"]), TO.ENTITY)
entity.act("$n sta cercando inutilmente qualcosa.", TO.OTHERS)
return False
arg2 = ""
location = entity.location
if argument:
arg2, argument = one_argument(argument)
# Rimuove eventuali argomenti facoltativi
if argument and arg == "in":
arg2, argument = one_argument(argument)
# Ricerca dell'entità bersaglio a cui dare l'entità target
location = entity.find_entity_extensively(arg2)
if not location:
entity.act("Non hai trovato nessun [white]%s[close] ove %s $N." % (arg2, verbs["infinitive"]), TO.ENTITY, target)
entity.act("$n non ha trovato nulla ove %s $N." % (verbs["infinitive"]), TO.OTHERS, target)
entity.act("$n non ha trovato nulla ove %s." % (verbs["you2"]), TO.TARGET, target)
return False
if not arg2:
arg2 = "da qualche parte"
# Se l'entità a cui dare si trova nell'inventario allora lo indica
inventory_message_you = ""
inventory_message_it = ""
if location and not location.IS_ROOM and location.location and location.location == entity:
inventory_message_you = ", nel tuo [yellow]inventario[close],"
inventory_message_it = ", nel suo [yellow]inventario[close],"
# Qui vengono gestite i due casi particolari in cui una delle due entità
# è stata trovata mentre l'altra no, e quella trovata corrisponde all'entità
# che ha inviato il comando
if target and not location and target == entity:
entity.act("Cerchi di %s [white]te stess$o[close] a [white]%s[close] che non trovi da [gray]nessuna parte[close]." % (verbs["infinitive"], arg2), TO.ENTITY, target)
entity.act("$n cerca di %s [white]sé stess$o[close] a [white]qualcuno[close] che non sembra trovare da [gray]nessuna parte[close]." % verbs["infinitive"], TO.OTHERS, target)
return False
elif not target and location and location == entity:
entity.act("Cerchi di [orange]passarti[close] da una $hand all'altra [white]%s[close], ma non trovi [gray]nulla del genere[close]." % arg1, TO.ENTITY, location)
entity.act("$n cerca di [orange]passarsi[close] da una $hand all'altra [white]qualcosa[close] che [gray]non sembra trovare[close].", TO.OTHERS, location)
return False
# Gestisce le tre combinazioni di entità non trovate
if target:
if not location:
entity.act("Cerchi di %s $N a [white]%s[close] che non trovi da [gray]nessuna parte[close]." % (verbs["infinitive"], arg2), TO.ENTITY, target)
entity.act("$n cerca di %s $N a [white]quacuno[close] che non sembra trovare da [gray]nessuna parte[close]." % verbs["infinitive"], TO.OTHERS, target)
entity.act("$n cerca di %s a [white]qualcuno[close] che non sembra trovare da [gray]nessuna parte[close]." % verbs["you2"], TO.TARGET, target)
return False
else:
if location:
entity.act("Cerchi di %s a $N%s un [white]%s[close], ma non trovi [gray]nulla del genere[close]." % (verbs["infinitive"], inventory_message_you, arg1), TO.ENTITY, location)
entity.act("$n cerca di %s a $N%s [white]qualcosa[close], ma non sembra trovare [gray]nulla del genere[close]." % (verbs["infinitive"], inventory_message_it), TO.OTHERS, location)
entity.act("$n cerca di %s [white]qualcosa[close], ma non sembra trovare [gray]nulla del genere[close]." % verbs["infinitive"], TO.TARGET, location)
else:
entity.act("Cerchi di %s [white]%s[close] a [white]%s[close], ma non trovi [gray]nulla e nessuno[close]." % (verbs["infinitive"], arg1, arg2), TO.ENTITY)
entity.act("$n cerca di %s [white]qualcosa[close] a [white]quacuno[close], ma [gray]senza molti risultati[close]." % verbs["infinitive"], TO.OTHERS)
return False
# Gestisce i tre casi in cui le entità trovate siano uguali a quella che ha
# inviato il comando
if target == entity:
if location == entity:
entity.act("Cerchi di %s tutt$o [white]te stess$o[close] a... te stess$o!" % verbs["infinitive"], TO.ENTITY)
entity.act("$n cerca di %s tutt$o [white]sé stess$o[close] a... sé stess$o!" % verbs["infinitive"], TO.OTHERS)
else:
entity.act("Cerchi di %s tutt$o [white]te stess$o[close] a $N..." % verbs["infinitive"], TO.ENTITY, location)
entity.act("$n cerca di %s tutt$o [white]sé stess$o[close] a $N..." % verbs["infinitive"], TO.OTHERS, location)
entity.act("$n cerca di %s tutt$o [white]sé stess$o[close] a te..." % verbs["infinitive"], TO.TARGET, location)
return False
else:
if location == entity:
entity.act("Ti [orange]passi[close] $N da una $hand all'altra.", TO.ENTITY, target)
entity.act("$n si [orange]passa[close] $N da una $hand all'altra.", TO.OTHERS, target)
entity.act("$n ti [orange]passa[close] da una $hand all'altra.", TO.TARGET, target)
return False
# Non si può seminare l'entità in sé stessa
if target == location:
entity.act("Cerchi di %s $N a [white]$LUI stess$O[close] senza molti risultati..." % verbs["infinitive"], TO.ENTITY, target)
entity.act("$n cerca di %s $N a [white]$LUI stess$O[close] senza molti risultati..." % verbs["infinitive"], TO.OTHERS, target)
entity.act("$n cerca di %s a [white]te stess$O[close] senza molti risultati..." % verbs["you2"], TO.TARGET, target)
return False
target_entitype = getattr(target, type_attr_name)
# Se l'entità è una pianta avvisa che è il caso di utilizzare il comando apposito
if command_name == "command_seed" and target.plant_type:
from src.commands.command_plant import VERBS as PLANT_VERBS
entity.act("Cerchi di %s $N ma faresti prima a %s." % (verbs["infinitive"], PLANT_VERBS["it2"]), TO.ENTITY, target)
entity.act("$n cerca di %s $N ma farebbe prima a %s." % (verbs["infinitive"], PLANT_VERBS["it2"]), TO.OTHERS, target)
entity.act("$n cerca di %s ma farebbe prima a %s." % (verbs["you2"], PLANT_VERBS["you2"]), TO.TARGET, target)
return False
# Come si può denotare invece è possibile seminare anche se l'entitype
# non è valido interrando successivamente così l'entità
if command_name == "command_plant" and not target_entitype:
entity.act("Cerchi di %s $N che però non sembra essera affatto una pianta." % verbs["infinitive"], TO.ENTITY, target)
entity.act("$n cerca di %s $N che però non sembra affatto essere una pianta." % verbs["infinitive"], TO.OTHERS, target)
entity.act("$n cerca di %s, ma tu sai di non essere una pianta." % verbs["you2"], TO.TARGET, target)
return False
ground = None
if location.IS_ROOM:
if (target_entitype and (target_entitype.sectors and location.sector not in target_entitype.sectors
or not target_entitype.sectors and not location.sector.fertile)):
entity.act("Cerchi di %s $N tuttavia il terreno non sembra essere adatto." % verbs["infinitive"], TO.ENTITY, target)
entity.act("$n cerca di %s $N tuttavia il terreno non sembra essere adatto." % verbs["infinitive"], TO.OTHERS, target)
entity.act("$n cerca di %s, tuttavia il terreno non sembra essere addato." % verbs["you2"], TO.TARGET, target)
return False
elif location.container_type:
for contains in location.iter_contains():
if contains.entitype == ENTITYPE.GROUND:
ground = contains
break
else:
entity.act("Cerchi di %s $N tuttavia non trovi del terreno adatto." % verbs["infinitive"], TO.ENTITY, target)
entity.act("$n cerca di %s $N tuttavia non trova del terreno terreno adatto." % verbs["infinitive"], TO.OTHERS, target)
entity.act("$n cerca di %s, tuttavia non trova del terreno addato." % verbs["you2"], TO.TARGET, target)
return False
elif location.entitype == ENTITYPE.GROUND:
ground = location
else:
entity.act("Cerchi di %s $N tuttavia non trovi del terreno adatto." % verbs["infinitive"], TO.ENTITY, target)
entity.act("$n cerca di %s $N tuttavia non trova del terreno terreno adatto." % verbs["infinitive"], TO.OTHERS, target)
entity.act("$n cerca di %s, tuttavia non trova del terreno addato." % verbs["you2"], TO.TARGET, target)
return False
if ground:
# Evita di far attecchire piante in un terreno se questo ha già un seme
# o una pianta in crescita
for contains in ground.iter_contains():
# E' voluto che vi siano potenzialmente più plant_type in uno
# stesso terreno, ma non più ENTITYPE.PLANT; stesso discorso
# con l'ENTITYPE.SEED
if contains.entitype == ENTITYPE.PLANT:
entity.act("Cerchi di %s $N tuttavia vi è già $a e non riuscirebbe ad attecchire in $A." % verbs["infinitive"], TO.ENTITY, target, contains, ground)
entity.act("$n cerca di %s $N tuttavia vi è già $a e non riuscirebbe ad attecchire in $A." % verbs["infinitive"], TO.OTHERS, target, contains, ground)
entity.act("$n cerca di %s, tuttavia vi è già $a e non riuscirebbe ad attecchire in $A." % verbs["you2"], TO.TARGET, target, contains, ground)
return False
elif contains.entitype == ENTITYPE.SEED:
entity.act("Cerchi di %s $N tuttavia noti che qui è già stato %s qualcosa." % (verbs["infinitive"], verbs["infinitive"]), TO.ENTITY, target)
entity.act("$n cerca di %s $N tuttavia nota che qui è già stato %s qualcosa." % (verbs["infinitive"], verbs["infinitive"]), TO.OTHERS, target)
entity.act("$n cerca di %s, tuttavia nota che qui è già stato %s qualcosa." % (verbs["you2"], verbs["infinitive"]), TO.TARGET, target)
return False
else:
# Per le staze invece il massimo piantabile è il numero i metri quadri
# della stanza meno il numero di oggetti già contenuti (visivamente,
# quindi mucchi di più oggetti valgono uno)
measured_area = (location.width * location.depth) / 100
if len(location.get_list_of_entities(entity)) >= measured_area:
entity.act("Cerchi di %s $N ma non hai spazio ove metterla." % verbs["infinitive"], TO.ENTITY, target)
entity.act("$n cerca di %s $N ma non hai spazio ove metterla." % verbs["infinitive"], TO.OTHERS, target)
entity.act("$n cerca di %s, ma non hai spazio ove metterla." % verbs["you2"], TO.TARGET, target)
return False
force_return = check_trigger(entity, "before_" + gamescript_suffix, entity, target, location, ground, behavioured)
if force_return:
return True
force_return = check_trigger(target, "before_" + gamescript_suffix + "ed", entity, target, location, ground, behavioured)
if force_return:
return True
force_return = check_trigger(location, "before_" + gamescript_suffix + "ing_in_location", entity, target, location, ground, behavioured)
if force_return:
return True
if inventory_message_you and inventory_message_it:
entity.act("%s $N in $a%s." % (color_first_upper(verbs["you"]), inventory_message_you[ : -1]), TO.ENTITY, target, location)
entity.act("$n %s $N in $a%s." % (verbs["it"], inventory_message_it[ : -1]), TO.OTHERS, target, location)
entity.act("$n ti %s in $a%s." % (verbs["it"], inventory_message_it[ : -1]), TO.TARGET, target, location)
entity.act("$n ti %s $a." % verbs["it"], TO.TARGET, location, target)
else:
entity.act("%s $N in $a." % color_first_upper(verbs["you"]), TO.ENTITY, target, location)
entity.act("$n %s $N in $a." % verbs["it"], TO.OTHERS, target, location)
entity.act("$n ti %s in $a." % verbs["it"], TO.TARGET, target, location)
entity.act("$n ti %s $a." % verbs["it"], TO.TARGET, location, target)
target = target.from_location(1, use_repop=True)
if ground:
# Se esiste del ground per la pianta questa attecchisce in esso
if not ground.container_type:
# (TD) scelta tecnica di dubbia qualità, da ripensare forse, è certo
# che se viene cambiata è da rivedere il check nell'iter_variant
container = Container()
container.max_weight = target.get_total_weight() * 2
ground.container_type = container
target.to_location(ground)
else:
target.to_location(location)
target.flags += FLAG.BURIED
if target_entitype:
target.flags += FLAG.GROWING
target_entitype.start_growth(target, type_attr_name)
# Dona un po' di esperienza ai giocatori che hanno piantato o seminato
# la prima volta l'entità
if entity.IS_PLAYER:
if target.prototype.code in entity.interred_entities:
entity.interred_entities[target.prototype.code] += 1
else:
entity.interred_entities[target.prototype.code] = 1
reason = "per aver interrato per la prima volta %s" % target.get_name(looker=entity)
entity.give_experience(target.level*10, reason=reason)
force_return = check_trigger(entity, "after_" + gamescript_suffix, entity, target, location, ground, behavioured)
if force_return:
return True
force_return = check_trigger(target, "after_" + gamescript_suffix + "ed", entity, target, location, ground, behavioured)
if force_return:
return True
force_return = check_trigger(location, "after_" + gamescript_suffix + "ing_in_location", entity, target, location, ground, behavioured)
if force_return:
return True
return True
def command_wear(entity, argument="", verbs=VERBS, behavioured=False):
"""
Permette di vestirsi di entità nelle varie parti del corpo.
"""
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)
if not argument:
entity.send_output("Che cosa vorresti %s?" % verbs["infinitive"])
if entity.IS_PLAYER and OPTION.NEWBIE in entity.account.options:
syntax = get_command_syntax(entity, "command_wear")
entity.send_output(syntax, break_line=False)
return False
# (TD) Controllo del mental state deviato
pass
# (TD) gestione di all (ti vesti di tutto punto: elenco delle cose indossate)
pass
original_argument = argument
arg, argument = one_argument(argument)
target = entity.find_entity(arg, location=entity)
if not target:
entity.act("Non hai nessun [white]%s[close] nel tuo inventario." % arg, TO.ENTITY)
entity.act("$n sembra frugare nel suo inventario cercando inutilmente qualcosa.", TO.OTHERS)
return False
if target == entity:
entity.act("Cerchi di %s da sol$o ma... sei sicur$o di quello che stai facendo?" % verbs["you2"], TO.ENTITY)
entity.act("$n sembra volersi %s da sol$o... Fa finta di non aver visto nulla!" % verbs["infinitive"], TO.OTHERS)
return False
chosen_part = None
if not argument:
if not target.wear_type:
entity.act("Non vedi come poter %s $N." % verbs["infinitive"], TO.ENTITY, target)
entity.act("$n cerca di %s $N ma senza grossi risultati." % verbs["infinitive"], TO.OTHERS, target)
return False
else:
# (TD) Scelta personalizzata della parte da vestire e/o di chi vestire
#chosen_part = search_part(argument)
pass
# (TD) bisognerà fare il supporto body anche per gli oggetti con le proprie parti
body_parts = entity.get_body_parts()
if not body_parts and not entity.IS_ITEM:
log.bug("body_parts non valido per l'entità %s di razza %s" % (entity.code, entity.race))
return False
# Ricava la modalità di wear uscendo dal comando se al corpo dell'entità
# gli mancano delle parti per poter indossare target oppure se l'entità ha
# già indossato qualcosa
chosen_mode = None
already_used_possession = None
for cycle in ("free", "layarable"):
for mode in target.wear_type.modes:
incompatible_part = None
already_weared_part = None
# Scorre tra le parti della modalità di wear per controllare discrepanze
# tra le parti del corpo della razza e quelle dell'entità da indossare
for part in mode:
if body_parts and part not in body_parts:
incompatible_part = part
break
if incompatible_part:
continue
# Supporto friendly per l'hold e il wield, così si possono impugnare o
# tenere entità anche tramite il comando wear
if PART.HOLD in mode:
return command_hold(entity, original_argument)
if PART.WIELD in mode:
return command_wield(entity, original_argument)
# Qui sotto c'è un altro ciclo uguale a quello sopra per dare
# maggiore priorità alle differenze razziali rispetto alle parti
# già indossate
for part in mode:
already_weared_part, already_weared_possession = check_if_part_is_already_weared(entity, part)
if already_weared_part:
break
# Se non ha trovato nessuna parte già indossata allora utilizza
# questa modalità di wear ed esce dal ciclo delle modalità
if not already_weared_possession or (cycle == "layarable" and already_weared_possession.is_layerable()):
chosen_mode = mode
break
if chosen_mode:
break
if incompatible_part:
# (TT) è stato deciso per ora di nascondere la parte del corpo per cui
# non si può indossare il vestito
#entity.act("Il tuo corpo non è adatto a poter indossare $N, ti manca %s." % incompatible_part, TO.ENTITY, target)
entity.act("Il tuo corpo non è adatto a poter %s $N." % verbs["infinitive"], TO.ENTITY, target)
entity.act("Il corpo di $n non è adatto a poter %s $N." % verbs["infinitive"], TO.OTHERS, target)
return False
if already_weared_possession and not already_weared_possession.is_layerable():
entity.act("Cerchi di %s $N %s ma hai già indosso $a." % (verbs["infinitive"], already_weared_part.description), TO.ENTITY, target, already_weared_possession)
entity.act("$n cerca di %s $N %s ma ha già indosso $a." % (verbs["infinitive"], already_weared_part.description), TO.OTHERS, target, already_weared_possession)
return False
# (TD) Aggiungere la flag di NO_WEAR (se la location ha la flag NO_WEAR
# anche il contenuto non potrà indossare, questo è da fare in vista del
# sistema generico entità-stanze)
pass
force_return = check_trigger(entity, "before_wear", entity, target, chosen_part, chosen_mode, behavioured)
if force_return:
return True
force_return = check_trigger(target, "before_weared", entity, target, chosen_part, chosen_mode, behavioured)
if force_return:
return True
if FLAG.INGESTED in target.flags:
if entity.trust >= TRUST.MASTER:
entity.send_to_admin("%s %s anche se lo stai digerendo." % (verbs["you"], target.get_name(entity)))
else:
log.bug("I giocatori non dovrebbero poter manipolare oggetti ingeriti")
entity.send_output("[cyan]Errore di digestione nel comando, gli amministratori sono stati avvertiti del problema.[close]")
return False
target.stop_digestion()
target.wear_mode.clear()
for part in chosen_mode:
target.wear_mode += part
if already_weared_possession:
target.under_weared = weakref.ref(already_weared_possession)
# Forza il posizionamento di target prima di already_weared_possession
# così che nelle manipolazioni venga prima quella sovrastante
list_of_target = getattr(entity, target.ACCESS_ATTR)
index = list_of_target.index(already_weared_possession)
if index != -1:
list_of_target.remove(target)
list_of_target.insert(index, target)
for affect in target.affects:
affect.apply()
# Poiché l'entità è stata vestita forse ha un valore nel gioco e non
# verrà quindi purificata
if target.deferred_purification:
target.stop_purification()
# Serve a cambiare il wear mode dell'oggetto allo stato originario
if target.repop_later:
target.deferred_repop = target.repop_later.defer_check_status()
part_descriptions = get_part_descriptions(target, "wear", entity, entity)
# (TD) estendere il verb a tutti i verbi degli act da inizio comando
send_wear_messages(entity, target, color_first_upper(verbs["you"]), verbs["it"], part_descriptions)
force_return = check_trigger(entity, "after_wear", entity, target, chosen_part, chosen_mode, behavioured)
if force_return:
return True
force_return = check_trigger(target, "after_weared", entity, target, chosen_part, chosen_mode, behavioured)
if force_return:
return True
return True
def command_loop(entity, argument):
"""
Permette di freezare il loop del gioco. Comodo per disattivare i behaviour
in fase di test.
"""
if not entity:
log.bug("entity non è un parametro valido: %r" % entity)
return False
# -------------------------------------------------------------------------
if not argument:
output = []
output.append(get_command_syntax(entity, "command_loop"))
output.append('''<table class="mud">''')
for loop in LOOPS:
loop_name = loop.__class__.__name__.replace("Loop", "").lower()
output.append('''<tr><td>Attualmente %s%s</td>''' % ("l'" if is_vowel(loop_name[0]) else "il ", loop_name))
output.append('''<td>%sè[close] in pausa</td>''' % ("[red]" if loop.paused else "[white]non "))
output.append('''<td>e%sè[close] stoppato.</td></tr>''' % (" [white]non " if loop.running else "d [red]"))
output.append('''</table>''')
output.append('''Ricordo che i reset non fanno parte dei loop, ma di un sistema di deferred separato.''')
entity.send_output("".join(output))
return False
# -------------------------------------------------------------------------
arg, argument = one_argument(argument)
for loop in LOOPS:
loop_name = loop.__class__.__name__.replace("Loop", "").lower()
if is_prefix(arg, loop_name):
break
else:
entity.send_output("Non esiste nessun loop chiamato [white]%s[close]" % arg)
return False
if not argument:
entity.send_output("Vuoi eseguire una [green]pausa[close] o un [green]continua[close] %s%s?" % (
"all'" if is_vowel(loop_name[0]) else "al ", loop_name))
return False
article = "L'" if is_vowel(loop_name[0]) else "Il "
if is_prefix(argument, ("pausa", "pause")):
if loop.paused:
entity.send_output("%s%s si trova già in pausa." % (article, loop_name))
else:
entity.send_output("%s%s ora è stato messo in pausa" % (article, loop_name))
loop.paused = True
elif is_prefix(argument, ("continua", "continue")):
if loop.paused:
entity.send_output("%s%s ora ricomincerà a girare." % (article, loop_name))
loop.paused = False
else:
entity.send_output("%s%s sta già girando." % (article, loop_name))
else:
entity.send_output("[white]%s[close] non è un argomento valido da passare al comando loop." % argument)
return False
return True
def command_destroy(entity, argument="", verbs=VERBS, behavioured=False):
# È possibile se il comando è stato deferrato
if not entity:
return False
entity = entity.split_entity(1)
if entity.sended_inputs and is_prefix("romp", entity.sended_inputs[-1]):
verbs = VERBS2
if not argument:
entity.send_output("Che cosa vorresti %s?" % verbs["infinitive"])
if entity.IS_PLAYER and OPTION.NEWBIE in entity.account.options:
syntax = get_command_syntax(entity, "command_destroy")
entity.send_output(syntax, destroy_line=False)
return False
# Solo gli oggetti animati possono utilizzare tale comando
if entity.IS_ITEM and FLAG.CAN_DAMAGING not in entity.flags:
entity.act("Non ti è possibile %s nulla di nulla.", TO.ENTITY)
entity.act("$n sembra vibrare per un attimo... ma forse è stato un abbaglio.", TO.OTHERS)
return False
# Ricava l'eventuale quantità d'oggetti da raccogliere
quantity, argument = quantity_argument(argument)
arg, argument = one_argument(argument)
target = entity.find_entity_extensively(arg, entity_tables=["items"], inventory_pos="first")
if not target:
target = entity.find_entity_extensively(arg, inventory_pos="first")
if target:
attack_translation = translate_input(entity, "attack", "en")
javascript_code = '''javascript:parent.sendInput('%s %s');''' % (attack_translation, target.get_numbered_keyword(looker=entity))
destroy_noun = verbs["noun"] % grammar_gender(target)
attack_noun = ATTACK_VERBS["noun"] % grammar_gender(target)
html_code = '''<a href="%s">%s</a>''' % (javascript_code, attack_noun)
entity.act("$N non è un oggetto quindi non puoi %s, ma puoi sempre %s." % (destroy_noun, html_code), TO.ENTITY, target)
entity.act("$n posa uno sguardo indagatore su $N.", TO.OTHERS, target)
entity.act("$n posa uno sguardo indagatore su di te.", TO.TARGET, target)
else:
entity.act("Non riesci a trovare nessun [white]%s[close] da %s" % (arg, verbs["infinitive"]), TO.ENTITY)
entity.act("$n cerca qualcosa che però non trova.", TO.OTHERS)
return False
# (TD) resistenza al comando se charmati
# (TD) skill di forza bruta
if quantity == 0:
quantity = target.quantity
elif target.quantity < quantity:
entity.act("Non puoi %s $N perché ve ne sono 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 %s" % ["you2"], TO.TARGET, target)
return False
# In questa maniera crea l'entità finale che verrà manipolata dai trigger
# in maniera omogenea senza dover attendere la chiamata della from_location
target = target.split_entity(quantity)
force_return = check_trigger(entity, "before_destroy", entity, target, behavioured)
if force_return:
return True
force_return = check_trigger(target, "before_broken", entity, target, behavioured)
if force_return:
return True
damage = damage_target(entity, target)
index, dam_verb_you, dam_verb_it = get_destroy_verbs(damage)
if target.life <= 0:
end_destroy(entity, target, verbs, behavioured)
else:
messages = {
"entity" : "%s $N." % dam_verb_you,
"others" : "$n %s $N." % dam_verb_it,
"target" : "$n ti %s." % dam_verb_it}
send_destroy_messages(messages, "start_destroy", entity, target, verbs)
if index != 0:
entity.action_in_progress = ActionInProgress(DESTROY_SECONDS, continue_destroy, stop_destroy, entity, target, verbs, behavioured)
return True
def command_read(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)
if not argument:
entity.send_output("Che cosa vorresti %s?" % verbs["infinitive"])
if entity.IS_PLAYER and OPTION.NEWBIE in entity.account.options:
syntax = get_command_syntax(entity, "command_read")
entity.send_output(syntax, break_line=False)
return False
arg1, argument = one_argument(argument)
arg2, argument = one_argument(argument)
location = None
if not arg2:
page_number = 0
elif is_number(arg2):
page_number = int(arg2)
else:
# Altrimenti cerca la locazione da cui leggere la extra o il readable
page_number = 0
if argument and is_number(argument):
page_number = int(argument)
location = entity.find_entity_extensively(arg2, inventory_pos="first")
if not location:
entity.act("Non riesci a trovare nessun [white]%s[close] da dove cercare di %s qualcosa." % (arg2, verbs["infinitive"]), TO.ENTITY)
entity.act("$n sembra voler %s da qualcosa che non trova." % verbs["infinitive"], TO.OTHERS)
return False
if location:
target = entity.find_entity(arg1, location=location)
else:
target = entity.find_entity_extensively(arg1, inventory_pos="first")
if not target:
result = read_extra_from_location(entity, location if location else entity.location, arg1, verbs, behavioured)
# (TT) non dovrebbero servire queste righe perché ci pensa la fine
# della read_extra_from_location, tuttavia ho un dubbio sulla
# sense_at_direction e quindi mantengo le linee per un po' a vedere...
#if not result:
# entity.act("Non riesci a trovare nessun [white]%s[close] da %s." % (arg1, verbs["infinitive"]), TO.ENTITY)
# entity.act("$n sembra voler %s qualcosa che non trova." % verbs["infinitive"], TO.OTHERS)
return result
if not target.readable_type:
entity.act("Non trovi modo di poter %s $N" % verbs["infinitive"], TO.ENTITY, target)
entity.act("$n non trova modo di poter %s $N" % verbs["infinitive"], TO.OTHERS, target)
return False
if page_number < 0:
entity.act("Cerchi di %s pagine inesistenti di $N." % verbs["infinitive"], TO.ENTITY, target)
entity.act("$n cerca di %s pagine inesistenti di $N" % verbs["infinitive"], TO.OTHERS, target)
return False
if page_number > len(target.readable_type.pages) - 1:
entity.act("Puoi %s solo fino alla %d° pagina di $N." % (verbs["infinitive"], len(target.readable_type.pages)-1), TO.ENTITY, target)
# E' voluto che qui il messaggio sia uguale a quello sopra, non è un copia e incolla selvaggio
entity.act("$n cerca di %s pagine inesistenti di $N" % verbs["infinitive"], TO.OTHERS, target)
return False
output = target.readable_type.get_pages(entity, target, page_number, location)
if not output:
log.bug("Output ricavato dalle pagine per il comando read con entità %s e book %s non valido: %r" % (entity.code, target.code, output))
return False
force_return = check_trigger(entity, "before_read", entity, target, output, None, behavioured)
if force_return:
return True
force_return = check_trigger(target, "before_readed", entity, target, output, None, behavioured)
if force_return:
return True
from_descr = ""
if location:
from_descr = " da %s" % location.get_name(looker=entity)
# Invia un messaggio adeguato di azione
previous_same_book = False
if entity.sended_inputs and len(entity.sended_inputs) > 2 and len(target.readable_type.pages) > 2 and page_number != 0 and page_number != len(target.readable_type.pages) - 1:
last_input, last_argument = one_argument(entity.sended_inputs[-2])
last_input, huh_input, language = multiple_search_on_inputs(entity, last_input)
last_argument, last_page_argument = one_argument(last_argument)
last_target = entity.find_entity(last_argument, location=entity)
if last_input and last_input.command.function == command_read and last_target and last_target == target:
previous_same_book = True
if last_page_argument and is_number(last_page_argument):
last_page_argument = int(last_page_argument)
if page_number > last_page_argument:
entity.act("Sfogli $N%s in avanti." % from_descr, TO.ENTITY, target)
entity.act("$n sfoglia $N%s in avanti." % from_descr, TO.OTHERS, target)
elif page_number < last_page_argument:
entity.act("Sfogli $N%s all'indietro." % from_descr, TO.ENTITY, target)
entity.act("$n sfoglia $N%s all'indietro." % from_descr, TO.OTHERS, target)
else:
entity.act("Continui a %s $N%s." % (verbs["infinitive"], from_descr), TO.ENTITY, target)
entity.act("$n continua a %s $N%s." % (verbs["infinitive"], from_descr), TO.OTHERS, target)
else:
entity.act("Continui a %s $N%s." % (verbs["infinitive"], from_descr), TO.ENTITY, target)
entity.act("$n continua a %s $N%s." % (verbs["infinitive"], from_descr), TO.OTHERS, target)
# Se non ha trovato che sia stato inviato un comando uguale precedentemente
# allora invia la messaggistica normale
if not previous_same_book:
if len(target.readable_type.pages) > 2:
if page_number == 0:
entity.act("%s la copertina di $N%s." % (color_first_upper(verbs["you"]), from_descr), TO.ENTITY, target)
entity.act("$n %s la copertina di $N%s." % (verbs["it"], from_descr), TO.OTHERS, target)
elif page_number == 1:
entity.act("Cominci a %s $N%s." % (verbs["infinitive"], from_descr), TO.ENTITY, target)
entity.act("$n comincia a %s $N%s." % (verbs["infinitive"], from_descr), TO.OTHERS, target)
elif page_number == len(target.readable_type.pages) - 1:
entity.act("%s la retrocopertina di $N%s." % (color_first_upper(verbs["you"]), from_descr), TO.ENTITY, target)
entity.act("$n %s la retrocopertina di $N%s." % (verbs["it"], from_descr), TO.OTHERS, target)
else:
entity.act("%s $N%s." % (color_first_upper(verbs["you"]), from_descr), TO.ENTITY, target)
entity.act("$n %s $N%s." % (verbs["it"], from_descr), TO.OTHERS, target)
else:
entity.act("%s $N%s." % (color_first_upper(verbs["you"]), from_descr), TO.ENTITY, target)
entity.act("$n %s $N%s." % (verbs["it"], from_descr), TO.OTHERS, target)
# Visualizza la o le pagine dell'entità leggibile al lettore
entity.send_output(output)
# Dona un po' di esperienza ai giocatori che leggono per la prima
# volta il libro
if entity.IS_PLAYER:
if target.prototype.code in entity.readed_books:
entity.readed_books[target.prototype.code] += 1
else:
entity.readed_books[target.prototype.code] = 1
reason = "per aver letto per la prima volta %s" % target.get_name(looker=entity)
entity.give_experience(target.level * 10, reason=reason)
force_return = check_trigger(entity, "after_read", entity, target, output, None, behavioured)
if force_return:
return True
force_return = check_trigger(target, "after_readed", entity, target, output, None, behavioured)
if force_return:
return True
return True
def command_countraces(entity, argument=""):
if not entity:
log.bug("entity non è un parametro valido: %r" % entity)
return False
# -------------------------------------------------------------------------
only_items = False
if not argument:
syntax = get_command_syntax(entity, "command_countraces")
entity.send_output(syntax, break_line=False)
else:
arg, argument = one_argument(argument)
if is_same(arg, "items") or (argument and is_same(argument, "items")):
only_items = True
if only_items:
attr_suffix = "items"
else:
attr_suffix = "mobs"
counter = {}
counter["totale"] = EnumElementDict()
for area in database["areas"].itervalues():
counter[area] = EnumElementDict()
targets = getattr(area, attr_suffix)
for target in targets:
if target.race == RACE.NONE:
continue
if target.race not in counter[area]:
counter[area][target.race] = 0
counter[area][target.race] += 1
if target.race not in counter["totale"]:
counter["totale"][target.race] = 0
counter["totale"][target.race] += 1
if only_items:
entity.send_output(
"\nLista del numero di razze degli oggetti suddivisi per area.",
break_line=False)
else:
entity.send_output(
"\nLista del numero di razze dei mob suddivisi per area.",
break_line=False)
output = []
for area in counter:
if not counter[area] or area == "totale":
continue
output.append('''<br>[%s]%s[close] (%s):''' %
(area.color.web_name, area.name, area.code))
output.append('''<table class="mud" style="width:75%">''')
for race_element in RACE.elements:
if race_element not in counter[area]:
continue
output.append(
'''<tr><td style="width:33%%">%s</td><td style="width:33%%">%s</td><td>%d</td></tr>'''
%
(race_element.code, race_element, counter[area][race_element]))
output.append('''</table>''')
if output:
output.append('''<br>[white]Gran Totale[close]:''')
output.append('''<table class="mud" style="width:75%">''')
for race_element in RACE.elements:
if race_element not in counter["totale"]:
continue
output.append(
'''<tr><td style="width:33%%">%s</td><td style="width:33%%">%s</td><td>%d</td></tr>'''
% (race_element.code, race_element,
counter["totale"][race_element]))
output.append('''</table>''')
entity.send_output("".join(output))
else:
entity.send_output('''<br>Nessuna!''')
return True
def command_loop(entity, argument):
"""
Permette di freezare il loop del gioco. Comodo per disattivare i behaviour
in fase di test.
"""
if not entity:
log.bug("entity non è un parametro valido: %r" % entity)
return False
# -------------------------------------------------------------------------
if not argument:
output = []
output.append(get_command_syntax(entity, "command_loop"))
output.append('''<table class="mud">''')
for loop in LOOPS:
loop_name = loop.__class__.__name__.replace("Loop", "").lower()
output.append(
'''<tr><td>Attualmente %s%s</td>''' %
("l'" if is_vowel(loop_name[0]) else "il ", loop_name))
output.append('''<td>%sè[close] in pausa</td>''' %
("[red]" if loop.paused else "[white]non "))
output.append('''<td>e%sè[close] stoppato.</td></tr>''' %
(" [white]non " if loop.running else "d [red]"))
output.append('''</table>''')
output.append(
'''Ricordo che i reset non fanno parte dei loop, ma di un sistema di deferred separato.'''
)
entity.send_output("".join(output))
return False
# -------------------------------------------------------------------------
arg, argument = one_argument(argument)
for loop in LOOPS:
loop_name = loop.__class__.__name__.replace("Loop", "").lower()
if is_prefix(arg, loop_name):
break
else:
entity.send_output("Non esiste nessun loop chiamato [white]%s[close]" %
arg)
return False
if not argument:
entity.send_output(
"Vuoi eseguire una [green]pausa[close] o un [green]continua[close] %s%s?"
% ("all'" if is_vowel(loop_name[0]) else "al ", loop_name))
return False
article = "L'" if is_vowel(loop_name[0]) else "Il "
if is_prefix(argument, ("pausa", "pause")):
if loop.paused:
entity.send_output("%s%s si trova già in pausa." %
(article, loop_name))
else:
entity.send_output("%s%s ora è stato messo in pausa" %
(article, loop_name))
loop.paused = True
elif is_prefix(argument, ("continua", "continue")):
if loop.paused:
entity.send_output("%s%s ora ricomincerà a girare." %
(article, loop_name))
loop.paused = False
else:
entity.send_output("%s%s sta già girando." % (article, loop_name))
else:
entity.send_output(
"[white]%s[close] non è un argomento valido da passare al comando loop."
% argument)
return False
return True
def command_buy(entity, argument="", verbs=VERBS, behavioured=False):
"""
Permette di comprare entità da un commerciante.
"""
# È possibile se il comando è stato deferrato
if not entity:
return False
entity = entity.split_entity(1)
if not argument:
entity.send_output("Cosa vorresti %s?" % verbs["infinitive"])
if entity.IS_PLAYER and OPTION.NEWBIE in entity.account.options:
syntax = get_command_syntax(entity, "command_buy")
entity.send_output(syntax, break_line=False)
return False
# Ricava la quantità di entità da comprare
quantity, argument = quantity_argument(argument)
arg, argument = one_argument(argument)
# Cerca specificatamente il negoziante con l'argomento passato
if argument:
dealer = entity.find_entity_extensively(argument, quantity=quantity)
if not dealer:
entity.act("Non trovi nessun negoziante chiamato [white]%s[close]." % argument, TO.ENTITY)
entity.act("$n sembra cercare qualcuno da cui %s qualcosa." % verbs["infinitive"], TO.OTHERS)
return False
if not dealer.shop:
entity.act("$N non sembra essere un negoziante da cui %s qualcosa." % verbs["infinitive"], TO.ENTITY, dealer)
entity.act("$n si accorge che $N non è un negoziante da cui %s qualcosa." % verbs["infinitive"], TO.OTHERS, dealer)
entity.act("$n si accorge che tu non sei un negoziante da cui %s qualcosa." % verbs["infinitive"], TO.TARGET, dealer)
return False
# Altrimenti cerca il primo negoziante che si trova nella locazione del giocatore
else:
for dealer in entity.location.iter_contains():
if dealer.shop:
break
else:
entity.act("Qui non trovi nessun [white]negoziante[close].", TO.ENTITY)
entity.act("$n non sembra trovare qualcuno da cui %s qualcosa." % verbs["infinitive"], TO.OTHERS)
return False
# Controlla se il negoziante si trova in una locazione che fa, per lui, da negozio
if not dealer.shop.in_location(dealer):
entity.act("Non puoi %s nulla da $N se non si trova nel suo negozio." % verbs["infinitive"], TO.ENTITY, dealer)
entity.act("$n non può %s nulla da $N se non si trova nel suo negozio." % verbs["infinitive"], TO.OTHERS, dealer)
entity.act("$n non può %s nulla da te se non ti trovi nel tuo negozio." % verbs["infinitive"], TO.TARGET, dealer)
return False
# Indica che un'entità vuole interagire con il dealer
if entity not in dealer.interactions:
dealer.interactions.append(entity)
# Ricava il magazzino del negoziante
storage = dealer.shop.get_storage(dealer)
if not storage:
if dealer.shop.proto_storages and dealer.shop.proto_storages[0].IS_MOB:
from_where = "da chi"
else:
from_where = "da dove"
entity.act("Non puoi %s nulla da $N perché non ha %s prendere la mercanzia!" % (verbs["infinitive"], from_where), TO.ENTITY, dealer)
entity.act("$n non può %s nulla da $N perché non ha %s prendere la mercanzia!" % (verbs["infinitive"], from_where), TO.OTHERS, dealer)
entity.act("$n non può %s nulla perché non hai %s prendere la mercanzia!" % (verbs["you2"], from_where), TO.TARGET, dealer)
return False
# Cerca l'oggetto voluto nel magazzino del negoziante
target = dealer.find_entity(arg, location=storage)
if not target:
descr = ""
if SHOP.DISPENSER in dealer.shop.types:
descr = "tra i prodotti esposti nel distributore"
else:
descr = "nella mercanzia esposta"
entity.act("Non trovi nessun [white]%s[close] %s." % (arg, descr), TO.ENTITY, dealer)
entity.act("$n non trova tra gli oggetti esposti da $N una [white]cosa[close] in particolare.", TO.OTHERS, dealer)
entity.act("$n non trova tra i tuoi oggetti esposti una [white]cosa[close] in particolare.", TO.TARGET, dealer)
return False
if quantity != 1 and SHOP.DISPENSER in dealer.shop.types:
entity.act("Non riesci in alcuni modo a %s %d quantità di $a da $N." % verbs["infinitive"], TO.ENTITY, dealer, target)
entity.act("$n non riesce in alcun modo a %s $a in quantità maggiore di una da $N." % verbs["infinitive"], TO.OTHERS, dealer, target)
entity.act("$n non riesce in alcun modo a %s $a in quantità maggiore di una da te." % verbs["infinitive"], TO.TARGET, dealer, target)
entity.act("$n non riesce in alcun modo a %s in quantità maggiore di una da $a." % verbs["you2"], TO.TARGET, target, dealer)
return False
# Controlla se in magazzino vi sia la quantità voluta dell'oggetto da comprare
if quantity == 0:
quantity = target.quantity
elif target.quantity < quantity:
entity.act("Puoi %s solo %d quantità di $N da $a, riprova più tardi." % (verbs["infinitive"], target.quantity), TO.ENTITY, target, dealer)
entity.act("$n può %s solo %d quantità di $N da $a." % (verbs["infinitive"], target.quantity), TO.OTHERS, target, dealer)
entity.act("$n può %s da $a solo in %d quantità." % (verbs["you2"], target.quantity), TO.TARGET, target, dealer)
entity.act("$n può %s $a da te solo in %d quantità." % (verbs["infinitive"], target.quantity), TO.TARGET, dealer, target)
return False
buyable = dealer.shop.get_buyable(target)
if not buyable:
entity.act("Ti accorgi che $N non è nel listino delle cose possibili da %s." % verbs["infinitive"], TO.ENTITY, target)
entity.act("$n si accorge che $N non è nel listino delle cose possibili da %s." % verbs["infinitive"], TO.OTHERS, target)
entity.act("$n si accorge che non sei nel listino delle cose possibili da %s." % verbs["infinitive"], TO.TARGET, target)
return False
price, discount = buyable.get_price(target, quantity=quantity)
pretty_price = pretty_money_value(price, extended=True)
# Controlla se il giocatore possa comprare un determinato articolo
if not can_afford(target.value * quantity, entity, race=dealer.race):
dealer.shop.send_cannot_afford_messages(entity, target, dealer, verbs, quantity, pretty_price)
return False
# Controlla se il giocatore può portare il peso dell'oggetto con sé
if not entity.can_carry_target(target, quantity=quantity):
if quantity <= 1:
entity.act("$N è troppo pesante perché tu possa portarl$O assieme alle tue cose.", TO.ENTITY, target, dealer)
entity.act("$N è troppo pesante perché $n lo possa portare assieme alle sue cose.", TO.OTHERS, target, dealer)
entity.act("Sei troppo pesante perché $n ti possa portare assieme alle sue cose.", TO.TARGET, target, dealer)
# l'act TO.OTHERS fa da 4° messaggio per dealer
else:
plural = grammar_gender(target, masculine="i", feminine="e")
entity.act("%d $N sono troppo pesanti perché tu possa portarl%s assieme alle tue cose." % (quantity, plural), TO.ENTITY, target, dealer) # (GR) plurare di $N
entity.act("%d $N sono troppo pesanti perché $n l%s possa portare assieme alle sue cose." % (quantity, plural), TO.OTHERS, target, dealer) # (GR) plurare di $N
entity.act("Siete troppo pesanti perché $n vi possa portare assieme alle sue cose.", TO.TARGET, target, dealer)
# l'act TO.OTHERS fa da 4° messaggio per dealer
return False
force_return = check_trigger(entity, "before_buy", entity, dealer, target, quantity, behavioured)
if force_return:
return True
force_return = check_trigger(dealer, "before_buying", entity, dealer, target, quantity, behavioured)
if force_return:
return True
force_return = check_trigger(target, "before_bought", entity, dealer, target, quantity, behavioured)
if force_return:
return True
dealer.shop.send_buy_messages(entity, target, dealer, verbs, quantity, pretty_price, discount)
give_moneys(entity, dealer, price, race=dealer.race)
target = target.from_location(quantity)
target.to_location(entity)
# Dona un po' di esperienza ai giocatori che hanno comprato per la prima
# volta l'entità
if entity.IS_PLAYER:
if target.prototype.code in entity.bought_entities:
entity.bought_entities[target.prototype.code] += 1
else:
entity.bought_entities[target.prototype.code] = 1
reason = "per aver comprato per la prima volta %s" % target.get_name(looker=entity)
entity.give_experience(target.level*10, reason=reason)
force_return = check_trigger(entity, "after_buy", entity, dealer, target, quantity, behavioured)
if force_return:
return True
force_return = check_trigger(dealer, "after_buying", entity, dealer, target, quantity, behavioured)
if force_return:
return True
force_return = check_trigger(target, "after_bought", entity, dealer, target, quantity, behavioured)
if force_return:
return True
return True
def interpret(entity, argument, use_check_alias=True, force_position=True, show_input=True, show_prompt=True, behavioured=False):
"""
Funzione che interpreta gli inputi inviati dalle entità.
L'argomento use_check_alias a False viene passato dalla find_alias per
evitare chiamate di alias da altri alias e quindi ricorsioni.
"""
if not entity:
log.bug("entity non è un parametro valido: %r" % entity)
return
if not argument:
log.bug("argument non è un parametro valido: %r" % argument)
return
# -------------------------------------------------------------------------
# Si assicura che colui che esegue l'azione sia un'entità unica e
# non un mucchio fisico
entity = entity.split_entity(1)
if FLAG.CONVERSING in entity.flags and len(argument) == 1 and is_number(argument):
# (TD)
return
arg, argument = one_argument(argument, search_separator=False)
arg = arg.lower()
input, huh_input, lang = multiple_search_on_inputs(entity, arg, use_check_alias=use_check_alias, argument=argument)
# Utilizzo bislacco di lang per indicare che è stato trovato un alias
# e che questo verrà processato tramite un'altra chiamata all'interpret
if use_check_alias and lang == "alias":
return
# Resetta l'inattività di un player se ha inviato un comando
if entity.IS_PLAYER:
entity.inactivity = 0
# Se non ha trovato nulla invia un messaggio apposito
if not input:
if show_input:
entity.send_output(''' <span class="system">%s %s</span>''' % (remove_colors(arg), argument))
entity.send_output("Huh?")
# Se l'input non è stato trovato neanche nell'altra lingua allora
# esegue il log dell'input, potrebbero esservene alcuni di sensati
# da utilizzare in futuro come sinonimi
# Scrive anche gli huh input dei mob così da ricavare gamescript o
# random_do_inputs errati
if not huh_input:
log.huh_inputs(entity, arg)
# Se serve visualizza il prompt
if show_input:
entity.send_prompt()
return False
# Poiché alcune words nello stesso input a volte hanno prefisso differente
# tra loro allora cerca quello più simile possibile per farlo visualizzare
# all'utente
founded_input = input.findable_words[0]
for word in input.findable_words:
if is_prefix(arg, word):
founded_input = word
break
# Se il giocatore è in stato di wait e l'input è un comando interattivo
# allora evita di inviarlo subito ma lo mette in coda
if entity.deferred_wait and CMDFLAG.INTERACT in input.command.flags:
entity.waiting_inputs.append("%s %s" % (founded_input, argument))
return False
else:
# Altrimenti scrive anche l'input a fianco del prompt
if show_input:
entity.send_output(''' <span class="system">%s %s</span>''' % (founded_input, argument))
# Se il pg si è scollegato dalla pagina di gioco non esegue il comando
if not entity.location:
return False
# Vengono salvate le informazioni sull'ultimo input inviato
if argument:
last_input = "%s %s" % (arg, argument)
else:
last_input = arg
engine.last_input_sender = entity
engine.last_input_sended = last_input
# Si salva l'ultimo input inviato con successo
if show_input and entity.IS_PLAYER and CMDFLAG.NO_LAST_INPUT not in input.command.flags:
entity.last_input = last_input
if CMDFLAG.GDR in input.command.flags:
entity.sended_inputs.append("%s %s" % (founded_input, argument))
if argument:
argument = html_escape(argument)
# Gestisce i comandi che devono essere digitati per intero
command = input.command
if CMDFLAG.TYPE_ALL in command.flags and not is_same(arg, input.findable_words):
first_words, other_words = one_argument(input.words, search_separator=False)
entity.send_output("Se vuoi veramente farlo devi scrivere per intero [limegreen]%s[close]." % first_words)
execution_result = False
elif not check_position(entity, command.position, force_position):
# Se la posizione non è corretta invia il relativo messaggio d'errore
vowel_of_genre = grammar_gender(entity)
if entity.position == POSITION.DEAD:
entity.send_output("Un po' difficile fino a che rimani MORT%s.." % vowel_of_genre.upper())
elif (entity.position == POSITION.MORTAL
or entity.position == POSITION.INCAP):
entity.send_output("Sei troppo ferit%s per farlo." % vowel_of_genre)
elif entity.position == POSITION.STUN:
entity.send_output("Sei troppo intontit%s per farlo." % vowel_of_genre)
elif entity.position == POSITION.SLEEP:
entity.send_output("Nei tuoi sogni, o cosa?")
elif entity.position == POSITION.REST:
entity.send_output("Nah.. Sei troppo rilassat%s ora.." % vowel_of_genre)
elif entity.position == POSITION.KNEE:
entity.send_output("Non puoi farlo da inginocchiat%s" % vowel_of_genre)
elif entity.position == POSITION.SIT:
entity.send_output("Non puoi farlo da sedut%s." % vowel_of_genre)
else:
log.bug("Manca la posizione %r" % entity.position)
execution_result = False
else:
if command.type == CMDTYPE.SOCIAL:
check_social(entity, command, argument=argument, behavioured=behavioured)
if CMDFLAG.PRIVATE not in command.flags and (entity.IS_PLAYER or config.print_entity_inputs) and show_input and show_prompt:
if entity.IS_PLAYER:
write_on_file = True
else:
write_on_file = False
log.input("'%s%s%s' digitato da %s in %s" % (
founded_input,
" " if argument else "",
argument,
entity.code,
entity.location.get_name()), write_on_file=write_on_file)
# Per comodità di sviluppo ricarica il modulo relativo al comando ogni
# volta che lo si digita, così da poter testare le modifiche al codice
# dei comandi senza aver bisogno di riavviare il gioco tutte le volte
if config.reload_commands:
reload(command.module)
command.import_module_and_function()
# Se si sta eseguendo un'azione che richiede tempo la interrompe
if entity.action_in_progress and CMDFLAG.INTERACT in command.flags:
if entity.action_in_progress.defer_later:
entity.action_in_progress.stop()
entity.action_in_progress = None
# Esegue la funzione del comando cronometrandola
input.counter_use += 1
starting_time = time.time()
execution_result = (command.function)(entity, argument)
if command.fun_name[ : 8] == "command_" and execution_result != True and execution_result != False:
log.bug("execution_result non è valido per il comando %s: %r" % (command.fun_name, execution_result))
if command.fun_name[ : 6] == "skill_" and execution_result != "clumsy" and execution_result != "failure" and execution_result != "success" and execution_result != "magistral":
log.bug("execution_result non è valido per la skill %s: %r" % (command.fun_name, execution_result))
execution_time = time.time() - starting_time
# Comandi che superano il tempo definito nella max_execution_time
# possono portare a bachi creati dalla deferred impostata nel metodo
# split_entity (nello stesso metodo c'è un commento con più informazioni)
# Quindi devono essere il più possibile da evitare, allo stesso tempo
# sarebbe meglio che il max_execution_time sia relativamente basso.
if execution_time > config.max_execution_time:
log.time("Il comando %s è stato eseguito in troppo tempo: %f secondi" % (command.fun_name, execution_time))
command.timer += execution_time
# Gestisce i comandi da loggare
if CMDFLAG.LOG in command.flags:
log.command("%s %s" % (command.fun_name, argument))
if FLAG.AFK in entity.flags and command.fun_name != "command_afk":
command_afk(entity)
# Infine visualizza il prompt
if show_prompt:
entity.send_prompt()
# Se la lista di input ancora da inviare non è vuota allora crea un
# "falso wait" per forzarne l'invio. In teoria potrei inviarlo da qui, ma
# il codice di ritorno execution_result andrebbe perduto, ecco perché
# si fa uso della wait().
if not entity.deferred_wait and entity.waiting_inputs:
entity.wait(0.001)
# Questa parte è da attivare con l'opzione check_references solo nei
# server di test perché consuma molta cpu essendo eseguita su migliaia
# di dati ad ogni invio di input, è una modalità di diagnostica
# che non bada a spese in termini prestazionali
if config.check_references and not database.reference_error_found:
database.check_all_references()
return execution_result
def interpret(entity,
argument,
use_check_alias=True,
force_position=True,
show_input=True,
show_prompt=True,
behavioured=False):
"""
Funzione che interpreta gli inputi inviati dalle entità.
L'argomento use_check_alias a False viene passato dalla find_alias per
evitare chiamate di alias da altri alias e quindi ricorsioni.
"""
if not entity:
log.bug("entity non è un parametro valido: %r" % entity)
return
if not argument:
log.bug("argument non è un parametro valido: %r" % argument)
return
# -------------------------------------------------------------------------
# Si assicura che colui che esegue l'azione sia un'entità unica e
# non un mucchio fisico
entity = entity.split_entity(1)
if FLAG.CONVERSING in entity.flags and len(argument) == 1 and is_number(
argument):
# (TD)
return
arg, argument = one_argument(argument, search_separator=False)
arg = arg.lower()
input, huh_input, lang = multiple_search_on_inputs(
entity, arg, use_check_alias=use_check_alias, argument=argument)
# Utilizzo bislacco di lang per indicare che è stato trovato un alias
# e che questo verrà processato tramite un'altra chiamata all'interpret
if use_check_alias and lang == "alias":
return
# Resetta l'inattività di un player se ha inviato un comando
if entity.IS_PLAYER:
entity.inactivity = 0
# Se non ha trovato nulla invia un messaggio apposito
if not input:
if show_input:
entity.send_output(''' <span class="system">%s %s</span>''' %
(remove_colors(arg), argument))
entity.send_output("Huh?")
# Se l'input non è stato trovato neanche nell'altra lingua allora
# esegue il log dell'input, potrebbero esservene alcuni di sensati
# da utilizzare in futuro come sinonimi
# Scrive anche gli huh input dei mob così da ricavare gamescript o
# random_do_inputs errati
if not huh_input:
log.huh_inputs(entity, arg)
# Se serve visualizza il prompt
if show_input:
entity.send_prompt()
return False
# Poiché alcune words nello stesso input a volte hanno prefisso differente
# tra loro allora cerca quello più simile possibile per farlo visualizzare
# all'utente
founded_input = input.findable_words[0]
for word in input.findable_words:
if is_prefix(arg, word):
founded_input = word
break
# Se il giocatore è in stato di wait e l'input è un comando interattivo
# allora evita di inviarlo subito ma lo mette in coda
if entity.deferred_wait and CMDFLAG.INTERACT in input.command.flags:
entity.waiting_inputs.append("%s %s" % (founded_input, argument))
return False
else:
# Altrimenti scrive anche l'input a fianco del prompt
if show_input:
entity.send_output(''' <span class="system">%s %s</span>''' %
(founded_input, argument))
# Se il pg si è scollegato dalla pagina di gioco non esegue il comando
if not entity.location:
return False
# Vengono salvate le informazioni sull'ultimo input inviato
if argument:
last_input = "%s %s" % (arg, argument)
else:
last_input = arg
engine.last_input_sender = entity
engine.last_input_sended = last_input
# Si salva l'ultimo input inviato con successo
if show_input and entity.IS_PLAYER and CMDFLAG.NO_LAST_INPUT not in input.command.flags:
entity.last_input = last_input
if CMDFLAG.GDR in input.command.flags:
entity.sended_inputs.append("%s %s" % (founded_input, argument))
if argument:
argument = html_escape(argument)
# Gestisce i comandi che devono essere digitati per intero
command = input.command
if CMDFLAG.TYPE_ALL in command.flags and not is_same(
arg, input.findable_words):
first_words, other_words = one_argument(input.words,
search_separator=False)
entity.send_output(
"Se vuoi veramente farlo devi scrivere per intero [limegreen]%s[close]."
% first_words)
execution_result = False
elif not check_position(entity, command.position, force_position):
# Se la posizione non è corretta invia il relativo messaggio d'errore
vowel_of_genre = grammar_gender(entity)
if entity.position == POSITION.DEAD:
entity.send_output("Un po' difficile fino a che rimani MORT%s.." %
vowel_of_genre.upper())
elif (entity.position == POSITION.MORTAL
or entity.position == POSITION.INCAP):
entity.send_output("Sei troppo ferit%s per farlo." %
vowel_of_genre)
elif entity.position == POSITION.STUN:
entity.send_output("Sei troppo intontit%s per farlo." %
vowel_of_genre)
elif entity.position == POSITION.SLEEP:
entity.send_output("Nei tuoi sogni, o cosa?")
elif entity.position == POSITION.REST:
entity.send_output("Nah.. Sei troppo rilassat%s ora.." %
vowel_of_genre)
elif entity.position == POSITION.KNEE:
entity.send_output("Non puoi farlo da inginocchiat%s" %
vowel_of_genre)
elif entity.position == POSITION.SIT:
entity.send_output("Non puoi farlo da sedut%s." % vowel_of_genre)
else:
log.bug("Manca la posizione %r" % entity.position)
execution_result = False
else:
if command.type == CMDTYPE.SOCIAL:
check_social(entity,
command,
argument=argument,
behavioured=behavioured)
if CMDFLAG.PRIVATE not in command.flags and (
entity.IS_PLAYER
or config.print_entity_inputs) and show_input and show_prompt:
if entity.IS_PLAYER:
write_on_file = True
else:
write_on_file = False
log.input("'%s%s%s' digitato da %s in %s" %
(founded_input, " " if argument else "", argument,
entity.code, entity.location.get_name()),
write_on_file=write_on_file)
# Per comodità di sviluppo ricarica il modulo relativo al comando ogni
# volta che lo si digita, così da poter testare le modifiche al codice
# dei comandi senza aver bisogno di riavviare il gioco tutte le volte
if config.reload_commands:
reload(command.module)
command.import_module_and_function()
# Se si sta eseguendo un'azione che richiede tempo la interrompe
if entity.action_in_progress and CMDFLAG.INTERACT in command.flags:
if entity.action_in_progress.defer_later:
entity.action_in_progress.stop()
entity.action_in_progress = None
# Esegue la funzione del comando cronometrandola
input.counter_use += 1
starting_time = time.time()
execution_result = (command.function)(entity, argument)
if command.fun_name[:
8] == "command_" and execution_result != True and execution_result != False:
log.bug("execution_result non è valido per il comando %s: %r" %
(command.fun_name, execution_result))
if command.fun_name[:
6] == "skill_" and execution_result != "clumsy" and execution_result != "failure" and execution_result != "success" and execution_result != "magistral":
log.bug("execution_result non è valido per la skill %s: %r" %
(command.fun_name, execution_result))
execution_time = time.time() - starting_time
# Comandi che superano il tempo definito nella max_execution_time
# possono portare a bachi creati dalla deferred impostata nel metodo
# split_entity (nello stesso metodo c'è un commento con più informazioni)
# Quindi devono essere il più possibile da evitare, allo stesso tempo
# sarebbe meglio che il max_execution_time sia relativamente basso.
if execution_time > config.max_execution_time:
log.time(
"Il comando %s è stato eseguito in troppo tempo: %f secondi" %
(command.fun_name, execution_time))
command.timer += execution_time
# Gestisce i comandi da loggare
if CMDFLAG.LOG in command.flags:
log.command("%s %s" % (command.fun_name, argument))
if FLAG.AFK in entity.flags and command.fun_name != "command_afk":
command_afk(entity)
# Infine visualizza il prompt
if show_prompt:
entity.send_prompt()
# Se la lista di input ancora da inviare non è vuota allora crea un
# "falso wait" per forzarne l'invio. In teoria potrei inviarlo da qui, ma
# il codice di ritorno execution_result andrebbe perduto, ecco perché
# si fa uso della wait().
if not entity.deferred_wait and entity.waiting_inputs:
entity.wait(0.001)
# Questa parte è da attivare con l'opzione check_references solo nei
# server di test perché consuma molta cpu essendo eseguita su migliaia
# di dati ad ogni invio di input, è una modalità di diagnostica
# che non bada a spese in termini prestazionali
if config.check_references and not database.reference_error_found:
database.check_all_references()
return execution_result
def command_force(entity, argument=""):
"""
Forza l'esecuzione di un comando da parte di un'altra entità.
"""
if not entity:
log.bug("entity non è un parametro valido: %r" % entity)
return False
# -------------------------------------------------------------------------
if not argument:
syntax = get_command_syntax(entity, "command_force")
entity.send_output(syntax, break_line=False)
return False
arg1, argument = one_argument(argument)
target = entity.find_entity_extensively(arg1, inventory_pos="first")
if not target:
target = entity.find_entity_extensively(arg1)
if not target:
entity.send_output("Nessuna entità trovata con argomento [white]%s[close]" % arg1)
return False
arg2, argument = one_argument(argument)
if not arg2:
entity.send_output("Che comando vorresti [red]forzare[close] a %s?" % target.get_name(entity))
return False
input, huh_input, input_lang = multiple_search_on_inputs(entity, arg2)
if not input:
entity.send_output("L'argomento %s non è relativo ad un comando valido." % arg2)
return False
if input.command and input.command.fun_name == "command_force":
entity.send_output("Non puoi forzare un force.")
return False
translated_input = translate_input(target, arg2, input_lang)
if not translated_input:
entity.send_output("Non è stato possibile tradurre l'input %s per %s (lingua originale: %s)" % (
arg2, target.get_name(entity), input_lang))
return False
target.send_output("\n")
execution_result = interpret(target, "%s %s" % (translated_input, argument), force_position=True, show_input=False)
if not execution_result:
if target == entity:
entity.send_output("\nL'esecuzione dell'input [limegreen]%s[close] forzato su di [white]te stess%c[close] non è andata a buon fine." % (
arg2, grammar_gender(entity)))
else:
entity.send_output("\nL'esecuzione dell'input %s forzato su di %s non è andata a buon fine." % (
arg2, target.get_name(entity)))
if not entity.incognito:
target.send_output("\n%s ti ha forzato a fare qualcosa." % entity.get_name(target))
log.admin("%s ha cercato di forzare %s a fare: %s %s" % (entity.name, target.name, arg2, argument))
return False
if target == entity:
message = "\n" + format_for_admin("Il force dell'input [green]%s[close] su [white]te stess%c[close] sembra essere andato a buon fine." % (
arg2, grammar_gender(entity)))
entity.send_output(message)
else:
message = "\n" + format_for_admin("Il force dell'input [green]%s[close] su di %s sembra andato a buon fine." % (
arg2, target.get_name(entity)))
entity.send_output(message)
if not entity.incognito:
target.send_output("\n%s ti ha forzato a fare qualcosa." % entity.get_name(target))
log.admin("%s ha forzato %s a fare: %s %s" % (entity.name, target.name, arg2, argument))
return True
def command_countraces(entity, argument=""):
if not entity:
log.bug("entity non è un parametro valido: %r" % entity)
return False
# -------------------------------------------------------------------------
only_items = False
if not argument:
syntax = get_command_syntax(entity, "command_countraces")
entity.send_output(syntax, break_line=False)
else:
arg, argument = one_argument(argument)
if is_same(arg, "items") or (argument and is_same(argument, "items")):
only_items = True
if only_items:
attr_suffix = "items"
else:
attr_suffix = "mobs"
counter = {}
counter["totale"] = EnumElementDict()
for area in database["areas"].itervalues():
counter[area] = EnumElementDict()
targets = getattr(area, attr_suffix)
for target in targets:
if target.race == RACE.NONE:
continue
if target.race not in counter[area]:
counter[area][target.race] = 0
counter[area][target.race] += 1
if target.race not in counter["totale"]:
counter["totale"][target.race] = 0
counter["totale"][target.race] += 1
if only_items:
entity.send_output("\nLista del numero di razze degli oggetti suddivisi per area.", break_line=False)
else:
entity.send_output("\nLista del numero di razze dei mob suddivisi per area.", break_line=False)
output = []
for area in counter:
if not counter[area] or area == "totale":
continue
output.append('''<br>[%s]%s[close] (%s):''' % (area.color.web_name, area.name, area.code))
output.append('''<table class="mud" style="width:75%">''')
for race_element in RACE.elements:
if race_element not in counter[area]:
continue
output.append('''<tr><td style="width:33%%">%s</td><td style="width:33%%">%s</td><td>%d</td></tr>''' % (
race_element.code, race_element, counter[area][race_element]))
output.append('''</table>''')
if output:
output.append('''<br>[white]Gran Totale[close]:''')
output.append('''<table class="mud" style="width:75%">''')
for race_element in RACE.elements:
if race_element not in counter["totale"]:
continue
output.append('''<tr><td style="width:33%%">%s</td><td style="width:33%%">%s</td><td>%d</td></tr>''' % (
race_element.code, race_element, counter["totale"][race_element]))
output.append('''</table>''')
entity.send_output("".join(output))
else:
entity.send_output('''<br>Nessuna!''')
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 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_tell(entity, argument=""):
"""
Permette di parlare con tutti nel Mud, in maniera off-gdr.
"""
if not entity:
log.bug("entity non è un parametro valido: %r" % entity)
return False
# -------------------------------------------------------------------------
if not argument:
entity.send_output("Vuoi %s a qualcuno che cosa?" % CHANNEL.TELL)
if entity.IS_PLAYER and OPTION.NEWBIE in entity.account.options:
syntax = get_command_syntax(entity, "command_tell")
entity.send_output(syntax, break_line=False)
return False
# Qui per la ricerca di target non viene utilizzata la find_entity perché
# deve cercare solo i giocatori online
# (TD) oltre alla ricerca di admin che possiedono mob o oggetti
arg, argument = one_argument(argument)
target = search_for_player(entity, arg)
if not target:
# (TD) se non è stato tovato allora cerca tra gli identificativi
# personali relativi ai personaggi invisibili (implementazione
# alternativa del reply)
entity.send_output("Non è stato trovato nessun giocatore con argomento [white]%s[close]" % arg)
return False
# (TD) possibile implementazione di NOTELL, anche se è preferibile punizione
# classica di NO_ENTER_IN_GAME per tot giorni
if entity == target:
entity.send_output("Non puoi comunicare con [white]te stess$o[close]!")
return False
if not target.game_request:
entity.send_output("Il giocatore [white]%s[close] è attualmente [darkslategray]offline[close]." % target.name)
return False
if not argument:
entity.send_output("Che messaggio privato vorresti inviare a [white]%s[close]?" % target.name)
return False
channel_color = get_first_color(str(CHANNEL.TELL))
afk_status = ""
if FLAG.AFK in target.flags:
if entity.account and OPTION.ITALIAN in entity.account.options:
afk_status = " (LDT)"
else:
afk_status = " (AFK)"
if is_vowel(remove_colors(target.name)[0]):
preposition = "ad"
else:
preposition = "a"
entity.send_output("%s %s%s[close] %s: %s'%s'" % (
CHANNEL.TELL.verb_you, channel_color, preposition, target.name, afk_status, argument), avoid_snoop=True)
# (TD) inviare anche il soft beep per avvertire che ha ricevuto un messaggio
# ed aggiungere l'opzione apposita
if target.get_conn().get_browser():
numbered_keyword = entity.get_numbered_keyword(looker=target)
javascript = '''javascript:putInput('%s %s ');''' % (translate_input(target, "tell", "en"), numbered_keyword)
target.send_output("""\n<a href="%s">%s%s ti[close]%s</a>: '%s'""" % (javascript, entity.name, channel_color, CHANNEL.TELL.verb_it, argument), avoid_snoop=True)
else:
target.send_output("""\n%s %sti[close]%s: '%s'""" % (entity.name, channel_color, CHANNEL.TELL.verb_it, argument), avoid_snoop=True)
target.send_prompt()
return True
def command_offer(entity, argument="", verbs=VERBS, behavioured=False):
"""
Permette di vendere entità ai commercianti.
"""
# È possibile se il comando è stato deferrato
if not entity:
return False
entity = entity.split_entity(1)
if not argument:
for dealer in entity.location.iter_contains():
if dealer.shop:
break
if SHOP.DISPENSER in dealer.shop.types:
entity.act("Cerchi di %s qualcosa a $N ma ciò non è possibile perché quest'ultim$O è un distributore." % verbs["infinitive"], TO.ENTITY, dealer)
entity.act("$n cerca di %s qualcosa a $N ma ciò non è possibile perché quest'ultim$O è un distributore." % verbs["infinitive"], TO.OTHERS, dealer)
entity.act("$n cerca di %s qualcosa ma ciò non è possibile perché sei un distributore." % verbs["you2"], TO.TARGET, dealer, target)
return False
entity.send_output("Cosa vorresti %s?" % verbs["infinitive"])
if entity.IS_PLAYER and OPTION.NEWBIE in entity.account.options:
syntax = get_command_syntax(entity, "command_offer")
entity.send_output(syntax, break_line=False)
return False
# Ricava la quantità da offrire e poi l'eventuale valore facoltativo del negoziante
quantity, argument = quantity_argument(argument)
arg, argument = one_argument(argument)
target = entity.find_entity(arg, quantity=quantity, location=entity)
if not target:
entity.act("Non trovi nessun [white]%s[close] da %s nel tuo inventario." % (arg, verbs["infinitive"]), TO.ENTITY)
entity.act("$n sta cercando qualcosa senza trovarla" % verbs["infinitive"], TO.OTHERS)
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 argument:
dealer = entity.find_entity_extensively(argument)
if not dealer:
entity.act("Non trovi nessun negoziante chiamato [white]%s[close] a cui %s $N." % (argument, verbs["infinitive"]), TO.ENTITY, target)
entity.act("$n sembra cercare qualcuno a cui %s $N." % verbs["infinitive"], TO.OTHERS, target)
return False
if not dealer.shop:
entity.act("$N non sembra essere un negoziante a cui %s $a." % verbs["infinitive"], TO.ENTITY, dealer, target)
entity.act("$n si accorge che $N non sembra essere un negoziante a cui %s $a." % verbs["infinitive"], TO.OTHERS, dealer, target)
entity.act("$n si accorge che tu non sei un negoziante a cui %s $a." % verbs["infinitive"], TO.TARGET, dealer, target)
return False
else:
for dealer in entity.location.iter_contains():
if dealer.shop:
break
else:
entity.act("Qui non trovi nessun negoziante a cui %s $N." % verbs["infinitive"], TO.ENTITY, target)
entity.act("$n non sembra trovare qualcuno a cui %s $N." % verbs["infinitive"], TO.OTHERS, target)
return False
# Controlla se il negoziante si trova in una locazione che fa, per lui, da negozio
if not dealer.shop.in_location(dealer):
entity.act("Non puoi %s nulla da $N se non si trova nel suo negozio." % verbs["infinitive"], TO.ENTITY, dealer)
entity.act("$n non può %s nulla da $N se non si trova nel suo negozio." % verbs["infinitive"], TO.OTHERS, dealer)
entity.act("$n non può %s nulla da te se non ti trovi nel tuo negozio." % verbs["infinitive"], TO.TARGET, dealer)
return False
# Indica che un'entità vuole interagire con il dealer
if entity not in dealer.interactions:
dealer.interactions.append(entity)
if SHOP.DISPENSER in dealer.shop.types:
entity.act("Cerchi di %s $a a $N ma ciò non è possibile perché quest'ultim$O è un distributore." % verbs["infinitive"], TO.ENTITY, dealer, target)
entity.act("$n cerca di %s $a a $N ma ciò non è possibile perché quest'ultim$O è un distributore." % verbs["infinitive"], TO.OTHERS, dealer, target)
entity.act("$n cerca di %s $a ma ciò non è possibile perché sei un distributore." % verbs["you2"], TO.TARGET, dealer, target)
entity.act("$n cerca di %s a $N ma ciò non è possibile perché è un distributore." % verbs["you2"], TO.TARGET, target, dealer)
return False
sellable = dealer.shop.get_sellable(target)
if not sellable:
dealer.shop.send_uninterested_messages(entity, target, dealer)
return False
price = math.trunc((target.value * sellable.percent) / 100) * quantity
if price <= 0:
entity.act("$N guarda senza molto interesse $a: è senza valore!", TO.ENTITY, dealer, target)
entity.act("$N guarda senza molto interesse $a mostrato da $n: è senza valore.", TO.OTHERS, dealer, target)
entity.act("Guardi senza molto interesse $a mostrato da $n: è senza valore...", TO.TARGET, dealer, target)
entity.act("$a ti guarda senza molto interesse: sei senza valore...", TO.TARGET, target, dealer)
return False
# Attenzione che qui target non è ancora la quantità giusta
force_return = check_trigger(entity, "before_offer", entity, dealer, target, quantity, behavioured)
if force_return:
return True
force_return = check_trigger(dealer, "before_offering", entity, dealer, target, quantity, behavioured)
if force_return:
return True
force_return = check_trigger(target, "before_offered", entity, dealer, target, quantity, behavioured)
if force_return:
return True
pretty_price = pretty_money_value(price, extended=True)
dealer.shop.send_offer_messages(entity, target, dealer, verbs, quantity, pretty_price)
force_return = check_trigger(entity, "after_offer", entity, dealer, target, quantity, behavioured)
if force_return:
return True
force_return = check_trigger(dealer, "after_offering", entity, dealer, target, quantity, behavioured)
if force_return:
return True
force_return = check_trigger(target, "after_offered", entity, dealer, target, quantity, behavioured)
if force_return:
return True
return True
def command_restring(entity, argument=""):
"""
Permette di modificare la short il nome e la descrizione dell'oggetto voluto.
"""
if not entity:
log.bug("entity non è un parametro valido: %r" % entity)
return False
# -------------------------------------------------------------------------
if not argument:
syntax = get_command_syntax(entity, "command_restring")
entity.send_output(syntax, break_line=False)
return False
arg1, argument = one_argument(argument)
target = entity.find_entity_extensively(arg1, inventory_pos="first")
if not target:
entity.send_output(
"Nessuna entità trovata con argomento [white]%s[close]." % arg1)
return False
if not argument:
output = "[white]%s[close]:\n" % target.code
output += '''<table class='mud'>'''
if not target.IS_PLAYER:
output += '''<tr><td>KeywordsName:</td><td>%s</td></tr>''' % target.keywords_name
output += '''<tr><td>KeywordsShort:</td><td>%s</td></tr>''' % target.keywords_short
output += '''<tr><td>KeywordsShortNight:</td><td>%s</td></tr>''' % target.keywords_short_night
output += '''<tr><td>Name:</td><td>%s</td></tr>''' % target.name
if target.short:
output += '''<tr><td>Short:</td><td>%s</td></tr>''' % target.short
if target.short_night:
output += '''<tr><td>ShortNight:</td><td>%s</td></tr>''' % target.short_night
if target.long:
output += '''<tr><td>Long:</td><td>%s</td></tr>''' % target.long
if target.long_night:
output += '''<tr><td>LongNight:</td><td>%s</td></tr>''' % target.long_night
output += '''<tr><td>Descr:</td><td>%s</td></tr>''' % target.descr
if target.descr_night:
output += '''<tr><td valign="top">DescrNight:</td><td>%s</td></tr>''' % target.descr_night
if target.descr_hearing:
output += '''<tr><td valign="top">DescrHearing:</td><td>%s</td></tr>''' % target.descr_hearing
if target.descr_hearing_night:
output += '''<tr><td valign="top">DescrHearingNight:</td><td>%s</td></tr>''' % target.descr_hearing_night
if target.descr_smell:
output += '''<tr><td valign="top">DescrSmell:</td><td>%s</td></tr>''' % target.descr_smell
if target.descr_smell_night:
output += '''<tr><td valign="top">DescrSmellNight:</td><td>%s</td></tr>''' % target.descr_smell_night
if target.descr_touch:
output += '''<tr><td valign="top">DescrTouch:</td><td>%s</td></tr>''' % target.descr_touch
if target.descr_touch_night:
output += '''<tr><td valign="top">DescrTouchNight:</td><td>%s</td></tr>''' % target.descr_touch_night
if target.descr_taste:
output += '''<tr><td valign="top">DescrTaste:</td><td>%s</td></tr>''' % target.descr_taste
if target.descr_taste_night:
output += '''<tr><td valign="top">DescrTasteNight:</td><td>%s</td></tr>''' % target.descr_taste_night
if target.descr_sixth:
output += '''<tr><td valign="top">DescrSixth:</td><td>%s</td></tr>''' % target.descr_sixth
if target.descr_sixth_night:
output += '''<tr><td valign="top">DescrSixthNight:</td><td>%s</td></tr>''' % target.descr_sixth_night
output += '''</table>'''
if target.IS_PLAYER and not target.game_request:
entity.send_output(
"Il giocatore %s è [darkslategray]offline[close]")
entity.send_output(output, break_line=False)
return True
arg2, argument = one_argument(argument)
attribute = ""
if is_prefix(arg2, ("KeywordsName", "keywords_name")):
attribute = "keywords_name"
attr_descr = "le parole chiavi del nome"
elif is_prefix(arg2, ("KeywordsShort", "keywords_short")):
attribute = "keywords_short"
attr_descr = "le parole chiavi della short"
elif is_prefix(arg2, ("KeywordsShortNight", "keywords_short_night")):
attribute = "keywords_short_night"
attr_descr = "le parole chiavi della short notturna"
elif is_prefix(arg2, ("Name", "nome")):
attribute = "name"
attr_descr = "il nome"
elif is_prefix(arg2, ("Short", "corta")):
attribute = "short"
attr_descr = "la short"
elif is_prefix(arg2, ("ShortNight", "short_night")):
attribute = "short_night"
attr_descr = "la short notturna"
elif is_prefix(arg2, ("Long", "lunga")):
attribute = "long"
attr_descr = "la long"
elif is_prefix(arg2, ("LongNight", "long_night")):
attribute = "long_night"
attr_descr = "la long notturna"
elif is_prefix(arg2, ("Descr", "descr", "Descrizione", "description")):
attribute = "descr"
attr_descr = "la descrizione"
elif is_prefix(arg2, ("DescrNight", "descr_night")):
attribute = "descr_night"
attr_descr = "la descrizione notturna"
elif is_prefix(arg2, ("DescrHearing", "descr_hearing")):
attribute = "descr_hearing"
attr_descr = "la descrizione uditiva"
elif is_prefix(arg2, ("DescrHearingNight", "descr_hearing_night")):
attribute = "descr_hearing_night"
attr_descr = "la descrizione uditiva notturna"
elif is_prefix(arg2, ("DescrSmell", "descr_smell")):
attribute = "descr_smell"
attr_descr = "la descrizione olfattiva"
elif is_prefix(arg2, ("DescrSmellNight", "descr_smell_night")):
attribute = "descr_smell_night"
attr_descr = "la descrizione olfattiva notturna"
elif is_prefix(arg2, ("DescrTouch", "descr_touch")):
attribute = "descr_touch"
attr_descr = "la descrizione tattile"
elif is_prefix(arg2, ("DescrTouchNight", "descr_touch_night")):
attribute = "descr_touch_night"
attr_descr = "la descrizione tattile notturna"
elif is_prefix(arg2, ("DescrTaste", "descr_taste")):
attribute = "descr_taste"
attr_descr = "la descrizione gustativa"
elif is_prefix(arg2, ("DescrTasteNight", "descr_taste_night")):
attribute = "descr_taste_night"
attr_descr = "la descrizione gustativa notturna"
elif is_prefix(arg2, ("DescrSixth", "descr_sixth")):
attribute = "descr_sixth"
attr_descr = "la descrizione intuitiva"
elif is_prefix(arg2, ("DescrSixthNight", "descr_sixth_night")):
attribute = "descr_sixth_night"
attr_descr = "la descrizione intuitiva notturna"
if not attribute:
syntax = "L'etichetta da modificare all'entità '%s' è errata: %s" % (
target.code, arg2)
syntax += get_command_syntax(entity, "command_restring")
entity.send_output(syntax, break_line=False)
return False
if not argument:
syntax = "Il testo da sostituire nell'etichetta è vuoto."
syntax += get_command_syntax(entity, "command_restring")
entity.send_output(syntax, break_line=False)
return False
if not check_colors(argument):
entity.send_output("Errore nella colorazione del testo: %s" % argument)
return False
if getattr(target, attribute) == argument:
entity.send_output(
"Inutile modificare %s di '%s' con un'altra stringa uguale." %
(attr_descr, target.code))
return False
# Se si sta rinominando un giocatore allora si tiene traccia del vecchio nome
if target.IS_PLAYER:
if attribute == "name":
argument = color_first_upper(argument)
err_msg_name = get_error_message_name(argument, True, "players")
if err_msg_name:
entity.send_output(err_msg_name)
return False
if not is_same(argument, target.name):
target.old_names += " " + target.name
# (TD) fare anche i messaggi d'avviso per gli altri attributi? da pensare
target.send_output("\nTi è stato cambiato il nome da %s a %s" %
(target.name, argument))
target.send_prompt()
elif attribute in ("keywords_name", "keywords_short",
"keywords_short_night"):
entity.send_output("È impossibile modificare %s nei giocatori." %
attr_descr)
return False
setattr(target, attribute, argument)
entity.send_output(
"Hai modificato il testo dell'etichetta %s di '%s' in %s" %
(to_capitalized_words(attribute), target.code, argument))
return True
def command_force(entity, argument=""):
"""
Forza l'esecuzione di un comando da parte di un'altra entità.
"""
if not entity:
log.bug("entity non è un parametro valido: %r" % entity)
return False
# -------------------------------------------------------------------------
if not argument:
syntax = get_command_syntax(entity, "command_force")
entity.send_output(syntax, break_line=False)
return False
arg1, argument = one_argument(argument)
target = entity.find_entity_extensively(arg1, inventory_pos="first")
if not target:
target = entity.find_entity_extensively(arg1)
if not target:
entity.send_output(
"Nessuna entità trovata con argomento [white]%s[close]" % arg1)
return False
arg2, argument = one_argument(argument)
if not arg2:
entity.send_output("Che comando vorresti [red]forzare[close] a %s?" %
target.get_name(entity))
return False
input, huh_input, input_lang = multiple_search_on_inputs(entity, arg2)
if not input:
entity.send_output(
"L'argomento %s non è relativo ad un comando valido." % arg2)
return False
if input.command and input.command.fun_name == "command_force":
entity.send_output("Non puoi forzare un force.")
return False
translated_input = translate_input(target, arg2, input_lang)
if not translated_input:
entity.send_output(
"Non è stato possibile tradurre l'input %s per %s (lingua originale: %s)"
% (arg2, target.get_name(entity), input_lang))
return False
target.send_output("\n")
execution_result = interpret(target,
"%s %s" % (translated_input, argument),
force_position=True,
show_input=False)
if not execution_result:
if target == entity:
entity.send_output(
"\nL'esecuzione dell'input [limegreen]%s[close] forzato su di [white]te stess%c[close] non è andata a buon fine."
% (arg2, grammar_gender(entity)))
else:
entity.send_output(
"\nL'esecuzione dell'input %s forzato su di %s non è andata a buon fine."
% (arg2, target.get_name(entity)))
if not entity.incognito:
target.send_output("\n%s ti ha forzato a fare qualcosa." %
entity.get_name(target))
log.admin("%s ha cercato di forzare %s a fare: %s %s" %
(entity.name, target.name, arg2, argument))
return False
if target == entity:
message = "\n" + format_for_admin(
"Il force dell'input [green]%s[close] su [white]te stess%c[close] sembra essere andato a buon fine."
% (arg2, grammar_gender(entity)))
entity.send_output(message)
else:
message = "\n" + format_for_admin(
"Il force dell'input [green]%s[close] su di %s sembra andato a buon fine."
% (arg2, target.get_name(entity)))
entity.send_output(message)
if not entity.incognito:
target.send_output("\n%s ti ha forzato a fare qualcosa." %
entity.get_name(target))
log.admin("%s ha forzato %s a fare: %s %s" %
(entity.name, target.name, arg2, argument))
return True
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 rpg_channel(entity, argument, channel, ask=False, exclaim=False, behavioured=False):
"""
Gestisce i canali rpg, ha le seguenti caratteristiche:
- supporto per gli smile
- supporto per i modi di esprimersi con esclamativo e punto di domanda
- supporto per gli emote
- gestione del bersaglio che può essere un'entità, il gruppo o sé stessi
- (TD) parlata da ubriaco
- (TD) espansione della potenza della voce in altre stanze
- (TD) espressioni per le stanze attorno, anche per coloro che riconoscono la voce,
pensare anche alla suddivisione tra social gestuali e 'rumorosi' per gli smile-espressioni around
- (TD) modulazione della voce a seconda delle dimensioni di chi parla e della sua voice_potence
"""
if not entity:
log.bug("entity non è un parametro valido: %r" % entity)
return False
if not channel:
log.bug("channel non è un parametro valido: %r" % channel)
return False
# -------------------------------------------------------------------------
if entity.IS_ROOM:
return False
objective = OBJECTIVE_ROOM # obiettivo del messaggio
# Linguaggio utilizzato per dire il messaggio
if entity.IS_ITEM:
language = LANGUAGE.COMMON
else:
language = entity.speaking
smile = "" # conterrà l'eventuale espressione di uno smile-social
emote = "" # conterrà l'eventuale emote inviato con il messaggio tra due asterischi
expres_entity = "" # espressione per chi parla
expres_room = "" # espressione per chi sta ascoltando nella stanza
expres_objective = "" # espressione per chi riceverà il messaggio
# Ricava i verbi e il colore relativi al canale
# Se si sta parlando normalmente la propria lingua vengono utilizzati
# i verbi razziali per descriverne timbro, flessione o pronuncia
if channel == CHANNEL.SAY:
verb_you, verb_it = entity.race.say_verb_you, entity.race.say_verb_it
else:
verb_you, verb_it = channel.verb_you, channel.verb_it
color = get_first_color(channel.name)
# Se non è stato passato nessun messaggio esce
if not argument or not remove_colors(argument):
entity.send_output("Cosa vorresti %s?" % channel)
return False
if len(argument) > config.max_google_translate:
entity.send_output("Non puoi %s un messaggio così logorroico." % channel)
return False
# Copia l'argomento originale, in alcuni casi serve recuperarlo poi
original_argument = argument
# Controlla se si sta parlando a qualcuno, il controllo sulla particella
# la esegue in minuscolo, dando per sottinteso che quando uno scrive
# maiuscolo voglia iniziare un discorso
target = None
if argument[0 : 2] == "a ":
arg, argument = one_argument(argument)
# Se sta parlando a qualcuno cerca di acquisirlo dal nome successivo
objective_name, argument = one_argument(argument)
target = entity.find_entity_extensively(objective_name)
# con me e self esegue un check senza la is_same volutamente, per evitare
# ricerche con nome di player che iniziano con Me o Self
if target == entity or objective_name in ("me", "self"):
objective = OBJECTIVE_SELF
# Se si parla da soli lo si fa utilizzando la lingua madre
language = entity.race.natural_language
elif target:
objective = OBJECTIVE_TARGET
# Se si parla con qualcuno della stessa razza lo si fa utilizzando
# la lingua preferita dalla razza, è un fattore culturale
if entity.race == target.race:
language = entity.race.natural_language
else:
# Se non ha trovato nessun 'a <nome bersaglio>' riprende
# l'argument originale
argument = original_argument
# Stessa cosa di sopra ma qui controlla se si stia parlando al gruppo
elif argument[0 : 3] == "al ":
arg, argument = one_argument(argument)
objective_name, argument = one_argument(argument)
if is_prefix(objective_name, "gruppo"):
if not entity.group:
entity.send_output("Non fai parte di nessun gruppo.")
return False
# Questa variabile verrà utilizza poi nell'invio del messaggio
group_members = entity.get_members_here(entity.location)
if not group_members:
entity.send_output("Non trovi nessun membro del gruppo vicino a te con cui poter parlare.")
return False
objective = OBJECTIVE_GROUP
# Se si parla in un gruppo in cui tutti sono formati dalla stessa
# razza si preferirà parlare con la lingua della propria razza
for group_member in group_members:
if group_member.race != entity.race:
break
else:
language = entity.race.natural_language
else:
# Se il personaggio non vuole parlare al gruppo recupera
# il valore originale inviato
argument = original_argument
# (TD) Gestisce il caso in cui l'entità si trovi immersa in un liquido
#if entity.is_immersed():
# entity.send_output("Tenti di %s qualcosa ma subito l'acqua ti riempie la gola soffocandoti!" % channel)
# entity.points.life -= random.randint(entity.level / 6, entity.level / 4) + 1
# return False
if not entity.location:
log.bug("entity %s non si trova in una locazione valida: %r (original_argument: %s)" % (
entity.code, entity.location, original_argument))
return False
# Gestisce le stanze che obbligano al silenzio
if entity.location.IS_ROOM:
if ROOM.SILENCE in entity.location.flags:
entity.send_output("Il silenzio del luogo ti blocca la gola impedendoti di %s." % channel)
return False
# (TT) Se nella stanza c'è molto casino, tante persone etc etc è difficile
# parlare piano
if entity.location.mod_noise > 75 and channel <= CHANNEL.SAY:
entity.send_output("Non puoi %s con tutta questa confusione!" % channel)
return False
# Invia l'appropriato messaggio nel caso in cui trovi argument vuoto
if not argument:
send_not_argument_message(entity, objective, channel)
return False
# Cerca eventuali smiles nella stringa controllando gli ultimi caratteri
for social in database["socials"].itervalues():
if not social.smiles:
continue
for single_smile in social.smiles.split():
if single_smile in argument[-config.chars_for_smile : ]:
break
else:
# Se non trova nessun smile esce dal ciclo dei social e continua
# col prossimo set di smiles trovato
continue
cut_smile = argument.rfind(single_smile)
# Se argument è formato solo dallo smile invia il corrispondente social
if cut_smile == 0:
social_name = social.fun_name[len("social_") : ]
if objective == OBJECTIVE_TARGET:
input_to_send = "%s %s" % (social_name, target.name)
elif objective == OBJECTIVE_SELF:
input_to_send = "%s %s" % (social_name, entity.name)
else:
input_to_send = social_name
send_input(entity, input_to_send, "en", show_input=False, show_prompt=False)
return True
# Altrimenti ne ricava l'espressione dello smile-social e toglie lo
# smile da argument, se il carattere dopo lo smile era un simbolo di
# punteggiatura lo attacca alla frase togliendo gli spazi
first_part = argument[ : cut_smile]
second_part = argument[cut_smile + len(single_smile) : ]
if second_part.strip() and second_part.strip()[0] in "!?.,:;":
first_part = first_part.rstrip()
second_part = second_part.lstrip()
argument = first_part.rstrip() + second_part.rstrip()
smile = " %s" % social.expression
break
# Elabora i punti esclamativi e interrogativi per il canale say.
# Qui viene utilizzata l'opzione chars_for_smile visto che si sta facendo
# una cosa simile a sopra, ovvero considerare solo l'ultima parte
# dell'argomento passato.
exclamations = argument[-config.chars_for_smile : ].count("!")
questions = argument[-config.chars_for_smile : ].count("?")
if exclamations > questions:
if channel == CHANNEL.SAY:
verb_you = "Esclami"
verb_it = " esclama"
exclaim = True
elif exclamations < questions:
if channel == CHANNEL.SAY:
verb_you = "Domandi"
verb_it = " domanda"
ask = True
# Questo elif sottintende che exclamations e questions siano uguali
elif exclamations != 0 and questions != 0:
# Con una stessa quantità di ! e di ? l'ultimo che viene trovato
# ha maggiore peso rispetto all'altro
exclamation_pos = argument.rfind("!")
question_pos = argument.rfind("?")
if exclamation_pos > question_pos:
if channel == CHANNEL.SAY:
verb_you = "Esclami"
verb_it = " esclama"
exclaim = True
else:
if channel == CHANNEL.SAY:
verb_you = "Domandi"
verb_it = " domanda"
ask = True
# Supporto per piccoli emote separati da * ad inizio argument
if argument[0] == "*":
cut_emote = argument[1 : ].find("*")
if cut_emote != -1:
emote = " %s" % argument[1 : cut_emote+1].strip()
if smile:
emote = " e%s" % emote
argument = argument[cut_emote+2 : ].strip()
# Unisce i vari pezzi per formare l'output
expres_entity = verb_you
expres_room = verb_it
expres_target = ""
if objective == OBJECTIVE_TARGET:
name = target.get_name(entity)
expres_entity += " a %s" % name
expres_room += " a %s" % name
expres_target += " ti%s" % verb_it
elif objective == OBJECTIVE_SELF:
expres_entity += " a te stess%s" % grammar_gender(entity)
expres_room += " a sé stess%s" % grammar_gender(entity)
elif objective == OBJECTIVE_GROUP:
members = entity.get_members_here(entity.location)
if len(members) == 1:
expres_entity += " a %s" % members[0].name
expres_room += " a %s" % members[0].name
expres_target += " ti%s" % verb_it
else:
if len(members) > 5:
many = "folto "
else:
many = ""
expres_entity += " al gruppo"
expres_room += " ad un %sgruppo" % many
expres_target += "%s al gruppo" % verb_it
# Aggiunge le eventuali espressioni dello smile e dell'emote
expres_entity += smile + emote
expres_room += smile + emote
expres_target += smile + emote
if not argument:
send_not_argument_message(entity, objective, channel)
return False
# Prepara il pezzo riguardante la lingua utilizzata
language = ""
if not entity.IS_ITEM and entity.speaking != LANGUAGE.COMMON:
language = " in lingua %s" % entity.speaking
# Mischia il testo se si è ubriachi
original_argument = argument = color_first_upper(argument)
argument = drunk_speech(argument, entity)
# Parlando si impara la lingua
if not entity.IS_ITEM:
learn_language(entity, channel, entity.speaking)
# Controlla se vi sono parolacce o parole offrpg e logga i relativi argument
if entity.IS_PLAYER:
check_for_badwords(entity, argument)
# Invia il messaggio a tutti coloro che lo possono sentire
for location in expand_voice_around(entity, channel):
if not location:
log.bug("location per il canale %s e per l'entità %s non è valida: %r" % (channel, entity.code, location))
continue
for listener in location.iter_contains(use_reversed=True):
if listener.position <= POSITION.SLEEP:
continue
if listener == entity:
force_return = check_trigger(entity, "before_rpg_channel", listener, entity, target, argument, ask, exclaim, behavioured)
if force_return:
continue
force_return = check_trigger(entity, "before_" + channel.trigger_suffix, listener, entity, target, argument, ask, exclaim, behavioured)
if force_return:
continue
# Invia all'entità il suo stesso messaggio
first_part = (close_color(color) + expres_entity).rstrip()
message = "%s: '%s'" % (first_part, close_color(argument))
send_channel_message(entity, message, True)
force_return = check_trigger(entity, "after_rpg_channel", listener, entity, target, argument, ask, exclaim, behavioured)
if force_return:
continue
force_return = check_trigger(entity, "after_" + channel.trigger_suffix, listener, entity, target, argument, ask, exclaim, behavioured)
if force_return:
continue
else:
# Fa ascoltare solo ad un'entità di un eventuale gruppo fisico
listener = listener.split_entity(1)
force_return = check_trigger(listener, "before_listen_rpg_channel", listener, entity, target, argument, ask, exclaim, behavioured)
if force_return:
continue
force_return = check_trigger(listener, "before_listen_" + channel.trigger_suffix, listener, entity, target, argument, ask, exclaim, behavioured)
if force_return:
continue
# Prepara alcune cose a seconda della stanza di provenienza del messaggio
if entity.location == listener.location:
entity_name = entity.get_name(listener)
entity_name = color_first_upper(entity_name)
from_direction = ""
elif entity.location.IS_ROOM:
# (TD) invia qualcuno a meno che non lo si abbia conosciuto
# precedentemente con il sistema di presentazione
entity_name = "Qualcuno"
from_direction = get_from_direction(listener.location.x, listener.location.y, listener.location.z,
entity.location.x, entity.location.y, entity.location.z)
elif entity.location.IS_ACTOR:
if entity.location != listener:
entity_name = "Qualcuno" # (TD) come sopra
from_direction = " dall'inventario di %s" % entity.location.get_name(listener)
else:
entity_name = "Qualcuno" # (TD) come sopra
from_direction = " da dentro %s" % entity.location.get_name(listener)
# Prepara la prima parte, quella senza il messaggio
if objective == OBJECTIVE_ROOM:
output = "%s%s%s%s" % (entity_name, close_color(color) + expres_room, language, from_direction)
elif objective == OBJECTIVE_TARGET or OBJECTIVE_SELF:
if listener == target:
output = "%s%s%s%s" % (entity_name, close_color(color) + expres_target, language, from_direction)
else:
output = "%s%s%s%s" % (entity_name, close_color(color) + expres_room, language, from_direction)
elif objective == OBJECTIVE_GROUP:
if listener in group_members:
output = "%s%s%s%s" % (entity_name, close_color(color) + expres_target, language, from_direction)
else:
output = "%s%s%s%s" % (entity_name, close_color(color) + expres_room, language, from_direction)
output = "<br>%s: '%s'" % (close_color(output).rstrip(), close_color(argument))
send_channel_message(listener, output, False)
listener.send_prompt()
force_return = check_trigger(listener, "after_listen_rpg_channel", listener, entity, target, argument, ask, exclaim, behavioured)
if force_return:
continue
force_return = check_trigger(listener, "after_listen_" + channel.trigger_suffix, listener, entity, target, argument, ask, exclaim, behavioured)
if force_return:
continue
return True
def command_use(entity, argument="", verbs=VERBS, behavioured=False):
"""
Permette di usare un'entità, tenterà di usare il comando relativo all'entità
e al suo stato.
"""
# È possibile se il comando è stato deferrato
if not entity:
return False
entity = entity.split_entity(1)
if not argument:
entity.send_output("Che cosa vorresti %s" % verbs["infinitive"])
if entity.IS_PLAYER and OPTION.NEWBIE in entity.account.options:
syntax = get_command_syntax(entity, "command_use")
entity.send_output(syntax, break_line=False)
return False
original_argument = argument
arg, argument = one_argument(argument)
target_for_eat_drink = entity.find_entity(arg, location=entity)
target_for_open_close = entity.find_entity_extensively(arg, inventory_pos="last")
target_for_enter = entity.find_entity_extensively(arg)
target_for_read = entity.find_entity_extensively(arg, inventory_pos="first")
target_for_remove = entity.find_equipped_entity(arg, entity)
target = target_for_eat_drink or target_for_open_close or target_for_enter or target_for_read or target_for_remove
if not target:
entity.act("Non trovi nessun [white]%s[close] da %s." % (arg, verbs["infinitive"]), TO.ENTITY)
entity.act("$n sembra cercare qualcosa che non riesce proprio a trovare.", TO.ENTITY)
return False
# È voluto che i trigger di use scattino anche su entità che non hanno una
# struttura di entitype valida, questo per dare la possibilità di inserire
# trigger su entità qualsiasi in maniera tale da poterle utilizzare per far
# scattare una qualsiasi cosa usandoli.
# Ricordo che se in un trigger viene ritornato un valore True il normale
# flusso di codice viene fermato, ecco cosa serve il force_return.
force_return = check_trigger(entity, "before_use", entity, target, argument, behavioured)
if force_return:
return True
force_return = check_trigger(target, "before_used", entity, target, argument, behavioured)
if force_return:
return True
# -------------------------------------------------------------------------
if target_for_open_close and target_for_open_close.entitype == ENTITYPE.CONTAINER and CONTAINER.CLOSABLE in target_for_open_close.container_type.flags:
if CONTAINER.BOLTED in target_for_open_close.container_type.flags:
return command_unbolt(entity, original_argument, behavioured=behavioured)
elif CONTAINER.LOCKED in target_for_open_close.container_type.flags:
return command_unlock(entity, original_argument, behavioured=behavioured)
elif CONTAINER.CLOSED in target_for_open_close.container_type.flags:
return command_open(entity, original_argument, behavioured=behavioured)
else:
return command_close(entity, original_argument, behavioured=behavioured)
elif target_for_open_close and target_for_open_close.entitype == ENTITYPE.DOOR and DOOR.CLOSABLE in target_for_open_close.door_type.flags:
if DOOR.BOLTED in target_for_open_close.door_type.flags:
return command_unbolt(entity, original_argument, behavioured=behavioured)
elif DOOR.LOCKED in target_for_open_close.door_type.flags:
return command_unlock(entity, original_argument, behavioured=behavioured)
elif DOOR.CLOSED in target_for_open_close.door_type.flags:
return command_open(entity, original_argument, behavioured=behavioured)
else:
return command_close(entity, original_argument, behavioured=behavioured)
elif target_for_eat_drink and target_for_eat_drink.entitype == ENTITYPE.DRINK:
return command_drink(entity, original_argument, behavioured=behavioured)
elif target_for_eat_drink and target_for_eat_drink.entitype == ENTITYPE.FOOD:
return command_eat(entity, original_argument, behavioured=behavioured)
# La ricerca del seme nel comando seme è uguale a quella del cibo e delle
# bevande, ecco perchè viene utilizzato comunque target_for_eat_drink
elif target_for_eat_drink and target_for_eat_drink.entitype == ENTITYPE.SEED:
return command_seed(entity, original_argument, behavioured=behavioured)
# La ricerca della pianta è uguale a quella del seme più sotto
elif target_for_eat_drink and target_for_eat_drink.entitype == ENTITYPE.PLANT:
return command_plant(entity, original_argument, behavioured=behavioured)
elif target_for_enter and target_for_enter.entitype == ENTITYPE.PORTAL:
return command_enter(entity, original_argument, behavioured=behavioured)
# C'è da notare relativamente al read che con il comando use non è possibile
# leggere entità dentro altre entità, poco male direi...
elif target_for_read and target_for_read.entitype == ENTITYPE.READABLE:
return command_read(entity, original_argument, behavioured=behavioured)
# Stesse considerazioni dette per il tipo seed
elif target_for_eat_drink and target_for_eat_drink.entitype == ENTITYPE.WEAR:
return command_wear(entity, original_argument, behavioured=behavioured)
# Stesse considerazioni dette per il tipo seed
elif target_for_eat_drink and target_for_eat_drink.entitype == ENTITYPE.WEAPON:
return command_wield(entity, original_argument, behavioured=behavioured)
elif target_for_remove and target_for_remove.entitype == ENTITYPE.WEAR:
return command_remove(entity, original_argument, behavioured=behavioured)
#elif target.entitype == ENTITYPE.CORPSE:
#elif target.entitype == ENTITYPE.FISHING:
#elif target.entitype == ENTITYPE.FLOWER:
#elif target.entitype == ENTITYPE.FRUIT:
#elif target.entitype == ENTITYPE.GROUND:
#elif target.entitype == ENTITYPE.INSTRUMENT:
#elif target.entitype == ENTITYPE.KEY:
#elif target.entitype == ENTITYPE.KEYRING:
#elif target.entitype == ENTITYPE.MENHIR:
#elif target.entitype == ENTITYPE.MONEY:
# -------------------------------------------------------------------------
entity.act("Non sai proprio come poter %s $N." % verbs["infinitive"], TO.ENTITY, target)
entity.act("$n non sa proprio come poter %s $N." % verbs["infinitive"], TO.OTHERS, target)
entity.act("$n non sa proprio come poter %s." % verbs["you2"], TO.TARGET, target)
# Per saperne di più sul perché questi trigger si trovato a questo livello
# è bene leggersi il commento in alto relativo agli altri trigger che vale
# anche per questa coppia
force_return = check_trigger(entity, "after_use", entity, target, argument, behavioured)
if force_return:
return True
force_return = check_trigger(target, "after_used", entity, target, argument, behavioured)
if force_return:
return True
return False
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 command_offer(entity, argument="", verbs=VERBS, behavioured=False):
"""
Permette di vendere entità ai commercianti.
"""
# È possibile se il comando è stato deferrato
if not entity:
return False
entity = entity.split_entity(1)
if not argument:
for dealer in entity.location.iter_contains():
if dealer.shop:
break
if SHOP.DISPENSER in dealer.shop.types:
entity.act(
"Cerchi di %s qualcosa a $N ma ciò non è possibile perché quest'ultim$O è un distributore."
% verbs["infinitive"], TO.ENTITY, dealer)
entity.act(
"$n cerca di %s qualcosa a $N ma ciò non è possibile perché quest'ultim$O è un distributore."
% verbs["infinitive"], TO.OTHERS, dealer)
entity.act(
"$n cerca di %s qualcosa ma ciò non è possibile perché sei un distributore."
% verbs["you2"], TO.TARGET, dealer, target)
return False
entity.send_output("Cosa vorresti %s?" % verbs["infinitive"])
if entity.IS_PLAYER and OPTION.NEWBIE in entity.account.options:
syntax = get_command_syntax(entity, "command_offer")
entity.send_output(syntax, break_line=False)
return False
# Ricava la quantità da offrire e poi l'eventuale valore facoltativo del negoziante
quantity, argument = quantity_argument(argument)
arg, argument = one_argument(argument)
target = entity.find_entity(arg, quantity=quantity, location=entity)
if not target:
entity.act(
"Non trovi nessun [white]%s[close] da %s nel tuo inventario." %
(arg, verbs["infinitive"]), TO.ENTITY)
entity.act(
"$n sta cercando qualcosa senza trovarla" % verbs["infinitive"],
TO.OTHERS)
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 argument:
dealer = entity.find_entity_extensively(argument)
if not dealer:
entity.act(
"Non trovi nessun negoziante chiamato [white]%s[close] a cui %s $N."
% (argument, verbs["infinitive"]), TO.ENTITY, target)
entity.act(
"$n sembra cercare qualcuno a cui %s $N." %
verbs["infinitive"], TO.OTHERS, target)
return False
if not dealer.shop:
entity.act(
"$N non sembra essere un negoziante a cui %s $a." %
verbs["infinitive"], TO.ENTITY, dealer, target)
entity.act(
"$n si accorge che $N non sembra essere un negoziante a cui %s $a."
% verbs["infinitive"], TO.OTHERS, dealer, target)
entity.act(
"$n si accorge che tu non sei un negoziante a cui %s $a." %
verbs["infinitive"], TO.TARGET, dealer, target)
return False
else:
for dealer in entity.location.iter_contains():
if dealer.shop:
break
else:
entity.act(
"Qui non trovi nessun negoziante a cui %s $N." %
verbs["infinitive"], TO.ENTITY, target)
entity.act(
"$n non sembra trovare qualcuno a cui %s $N." %
verbs["infinitive"], TO.OTHERS, target)
return False
# Controlla se il negoziante si trova in una locazione che fa, per lui, da negozio
if not dealer.shop.in_location(dealer):
entity.act(
"Non puoi %s nulla da $N se non si trova nel suo negozio." %
verbs["infinitive"], TO.ENTITY, dealer)
entity.act(
"$n non può %s nulla da $N se non si trova nel suo negozio." %
verbs["infinitive"], TO.OTHERS, dealer)
entity.act(
"$n non può %s nulla da te se non ti trovi nel tuo negozio." %
verbs["infinitive"], TO.TARGET, dealer)
return False
# Indica che un'entità vuole interagire con il dealer
if entity not in dealer.interactions:
dealer.interactions.append(entity)
if SHOP.DISPENSER in dealer.shop.types:
entity.act(
"Cerchi di %s $a a $N ma ciò non è possibile perché quest'ultim$O è un distributore."
% verbs["infinitive"], TO.ENTITY, dealer, target)
entity.act(
"$n cerca di %s $a a $N ma ciò non è possibile perché quest'ultim$O è un distributore."
% verbs["infinitive"], TO.OTHERS, dealer, target)
entity.act(
"$n cerca di %s $a ma ciò non è possibile perché sei un distributore."
% verbs["you2"], TO.TARGET, dealer, target)
entity.act(
"$n cerca di %s a $N ma ciò non è possibile perché è un distributore."
% verbs["you2"], TO.TARGET, target, dealer)
return False
sellable = dealer.shop.get_sellable(target)
if not sellable:
dealer.shop.send_uninterested_messages(entity, target, dealer)
return False
price = math.trunc((target.value * sellable.percent) / 100) * quantity
if price <= 0:
entity.act("$N guarda senza molto interesse $a: è senza valore!",
TO.ENTITY, dealer, target)
entity.act(
"$N guarda senza molto interesse $a mostrato da $n: è senza valore.",
TO.OTHERS, dealer, target)
entity.act(
"Guardi senza molto interesse $a mostrato da $n: è senza valore...",
TO.TARGET, dealer, target)
entity.act("$a ti guarda senza molto interesse: sei senza valore...",
TO.TARGET, target, dealer)
return False
# Attenzione che qui target non è ancora la quantità giusta
force_return = check_trigger(entity, "before_offer", entity, dealer,
target, quantity, behavioured)
if force_return:
return True
force_return = check_trigger(dealer, "before_offering", entity, dealer,
target, quantity, behavioured)
if force_return:
return True
force_return = check_trigger(target, "before_offered", entity, dealer,
target, quantity, behavioured)
if force_return:
return True
pretty_price = pretty_money_value(price, extended=True)
dealer.shop.send_offer_messages(entity, target, dealer, verbs, quantity,
pretty_price)
force_return = check_trigger(entity, "after_offer", entity, dealer, target,
quantity, behavioured)
if force_return:
return True
force_return = check_trigger(dealer, "after_offering", entity, dealer,
target, quantity, behavioured)
if force_return:
return True
force_return = check_trigger(target, "after_offered", entity, dealer,
target, quantity, behavioured)
if force_return:
return True
return True
def command_remove(entity, argument="", verbs=VERBS, behavioured=False):
"""
Permette di vestirsi di entità nelle varie parti del corpo.
"""
# È possibile se il comando è stato deferrato
if not entity:
return False
entity = entity.split_entity(1)
if not argument:
entity.send_output("Che cosa vorresti %s di dosso?" % verbs["you2"])
if entity.IS_PLAYER and OPTION.NEWBIE in entity.account.options:
syntax = get_command_syntax(entity, "command_remove")
entity.send_output(syntax)
return False
# (TD) Controllo del mental state deviato
pass
# (TD) gestione di all (ti vesti di tutto punto: elenco delle cose indossate)
pass
location = None
arg, argument = one_argument(argument)
if argument:
location = entity.find_entity(argument)
if not location:
entity.send_output("Non è stato trovato nessun %s da cui %s %s." % (argument, verbs["infinitive"], arg))
return False
target = entity.find_equipped_entity(arg, location)
else:
target = entity.find_equipped_entity(arg, entity)
if not target:
if is_masculine(arg):
descr = "indossato"
else:
descr = "indossata"
entity.act("Non hai nessun [white]%s[close] %s." % (arg, descr), TO.ENTITY)
entity.act("$n sembra cercare qualche cosa che ha addosso.", TO.OTHERS)
return False
if target == entity:
entity.act("Cerchi di %s di dosso ma... sei sicur$o di quello che stai facendo?" % verbs["you2"], TO.ENTITY)
entity.act("$n sembra volersi %s di dosso... Ma che sta facendo?" % verbs["infinitive"], TO.OTHERS)
return False
if location and location != entity and location.IS_ACTOR:
entity.send_output("Non ti è possibile %s %s da %s." % (verbs["infinitive"], targetget_name(looker=entity), location.get_name(looker=entity)))
return False
if FLAG.NO_REMOVE in target.flags:
if entity.trust > TRUST.MASTER:
entity.send_output("{Questa sarebbe in realtà un'entità NO_REMOVE}")
else:
entity.act("Appena cerchi di %s $N ti accorgi di non poterlo fare." % verbs["infinitive"], TO.ENTITY, target)
entity.act("Appena $n cerca di %s $N si accorge di non poterlo fare." % verbs["infinitive"], TO.OTHERS, target)
entity.act("\nAppena $n cerca di %s si accorge di non riuscirci." % verbs["you2"], TO.TARGET, target)
return False
# (TT) nel caso si sviluppino stanze no remove qui ci va il chk opportuno
if target.wear_type:
upper_weared = target.wear_type.get_upper_weared(target)
if upper_weared:
entity.act("Devi %s prima $a di $N." % verbs["you2"], TO.ENTITY, target, upper_weared)
entity.act("$n cerca di %s $N senza prima essersi %s $a." % (verbs["self"], verbs["participle"]), TO.OTHERS, target, upper_weared)
entity.act("$n cerca di %s senza prima essersi %s $a." % (verbs["you2"], verbs["participle"]), TO.TARGET, target, upper_weared)
entity.act("$n cerca di %s $N senza prima %s." % (verbs["self"], verbs["you2"]), TO.TARGET, target, upper_weared)
return False
chosen_part = None
if argument:
# (TD) rimuovere un'entità da una parte del corpo precisa
#chosen_part = search_part(argument)
pass
if config.reload_commands:
reload(__import__("src.commands.command_hold", globals(), locals(), [""]))
reload(__import__("src.commands.command_wield", globals(), locals(), [""]))
reload(__import__("src.commands.command_wear", globals(), locals(), [""]))
from src.commands.command_hold import VERBS as hold_verbs
from src.commands.command_wield import VERBS as wield_verbs
from src.commands.command_wear import VERBS as wear_verbs
force_return = check_trigger(entity, "before_remove", entity, target, location, chosen_part, behavioured)
if force_return:
return True
force_return = check_trigger(target, "before_removed", entity, target, location, chosen_part, behavioured)
if force_return:
return True
# Fare il sistema messaggistica proprio di tutti gli entitype
# (TD) estendere il sistema di verb dall'inizio del comando
part_descriptions = get_part_descriptions(target, "remove", entity, entity)
if PART.HOLD in target.wear_mode or PART.WIELD in target.wear_mode:
if target.weapon_type:
if entity == target.location:
part_descriptions[TO.ENTITY].replace(wield_verbs["participle"] + " ", "")
part_descriptions[TO.OTHERS].replace(wield_verbs["participle"] + " ", "")
part_descriptions[TO.TARGET].replace(wield_verbs["participle"] + " ", "")
send_remove_messages(entity, target, "Smetti d'" + wield_verbs["infinitive_min"], "smette d'" + wield_verbs["infinitive_min"], part_descriptions, True)
else:
part_descriptions[TO.ENTITY] = "da $L"
part_descriptions[TO.OTHERS] = "da $L"
part_descriptions[TO.TARGET] = "da $L"
send_remove_messages(entity, target, color_first_upper(verbs["you_min"]), verbs["it_min"], part_descriptions, True)
else:
if entity == target.location:
part_descriptions[TO.ENTITY].replace(hold_verbs["participle"] + " ", "")
part_descriptions[TO.OTHERS].replace(hold_verbs["participle"] + " ", "")
part_descriptions[TO.TARGET].replace(hold_verbs["participle"] + " ", "")
send_remove_messages(entity, target, "Smetti di " + hold_verbs["infinitive_min"], "smette di " + hold_verbs["infinitive_min"], part_descriptions, True)
else:
part_descriptions[TO.ENTITY] = "da $L"
part_descriptions[TO.OTHERS] = "da $L"
part_descriptions[TO.TARGET] = "da $L"
send_remove_messages(entity, target, color_first_upper(verbs["you_min"]), verbs["it_min"], part_descriptions, True)
else:
if entity == target.location:
send_remove_messages(entity, target, "Smetti d'" + wear_verbs["infinitive"], "smette d'" + wear_verbs["infinitive"], part_descriptions, False)
else:
part_descriptions[TO.ENTITY] = "da $L"
part_descriptions[TO.OTHERS] = "da $L"
part_descriptions[TO.TARGET] = "da $L"
send_remove_messages(entity, target, color_first_upper(verbs["you"]), verbs["it"], part_descriptions, False)
target.wear_mode.clear()
target.under_weared = None
if upper_weared:
upper_weared.under_weared = None
# Rimuove tutti gli affect che target stava applicando
for affect in target.affects:
affect.remove()
# Per oggetti rimossi ad altri oggetti li mette per terra, questo perché
# forza a raccoglierli, facendo scattare eventuali gamescript o altre flag
if location:
target = target.from_location(1, use_repop=False)
target.to_location(location.location)
# Serve a cambiare il wear mode dell'oggetto allo stato originario
if target.repop_later:
target.deferred_repop = target.repop_later.defer_check_status()
force_return = check_trigger(entity, "after_remove", entity, target, location, chosen_part, behavioured)
if force_return:
return True
force_return = check_trigger(target, "after_removed", entity, target, location, chosen_part, behavioured)
if force_return:
return True
return True
