def create_tooltip_specials(conn, obj):
if not conn:
if not engine.test_inputs_mode:
log.bug("conn non è un parametro valido: %r" % conn)
return ""
if not obj:
log.bug("obj non è un parametro valido: %r" % obj)
return ""
# -------------------------------------------------------------------------
tooltip = ["[royalblue]Specials[close]"]
for key, value in obj.specials.iteritems():
if value:
tooltip.append("%s = %s" % (key, html_escape(str(value))))
else:
tooltip.append("%s = %r" % (key, value))
if len(tooltip) == 1:
return ""
else:
from web_resource import create_tooltip
return create_tooltip(conn, "\n".join(tooltip), "{S}")
def get_command_syntax(entity, fun_name):
if not entity:
log.bug("entity non è un parametro valido: %r" % entity)
return ""
if not fun_name:
log.bug("fun_name non è un parametro valido: %r" % fun_name)
return ""
# -------------------------------------------------------------------------
module = database["commands"][fun_name].module
if not module:
log.bug("module non è valido: %r" % module)
return ""
syntax_string = getattr(module, "get_syntax_template")(entity)
if not syntax_string:
log.bug("syntax_string non è valida: %r" % syntax_string)
return ""
# Ricava il nome dell'input dalla funzione del comando
input_word = fun_name[fun_name.find("_") + 1:]
# Ricava la traduzione dell'input a seconda della lingua dei
# comandi utilizzata dall'entità
translation = translate_input(entity, input_word, "en")
# Preparare ed invia la tabella con la sintassi colorata del comando
output = '''<table class="mud">'''
for x, line in enumerate(syntax_string.split("\n")):
if not line.strip():
continue
# Esegue un replace di tutti i simboli di minore e maggiore che devono
# essere passati nella pagina come entità html
line = html_escape(line)
# Se trova uno spazio significa che ci sono argomenti aggiuntivi
# al comando normale che colora di verde più scuro
if " " in line:
line = line.replace(input_word,
"[limegreen]%s[close][green]" % translation, 1)
else:
line = line.replace(input_word, "[limegreen]%s" % translation, 1)
line = '''<td>%s[close]</td></tr>''' % line
# Alla prima linea inserisce la dicitura di Sintassi, alle altre dello
# spazio per incolonnare correttamente
if x == 0:
line = '''<tr><td>[yellow]Sintassi[close]:</td>%s''' % line
else:
line = '''<tr><td></td>%s''' % line
output += line
output += '''</table>'''
return output
def get_command_syntax(entity, fun_name):
if not entity:
log.bug("entity non è un parametro valido: %r" % entity)
return ""
if not fun_name:
log.bug("fun_name non è un parametro valido: %r" % fun_name)
return ""
# -------------------------------------------------------------------------
module = database["commands"][fun_name].module
if not module:
log.bug("module non è valido: %r" % module)
return ""
syntax_string = getattr(module, "get_syntax_template")(entity)
if not syntax_string:
log.bug("syntax_string non è valida: %r" % syntax_string)
return ""
# Ricava il nome dell'input dalla funzione del comando
input_word = fun_name[fun_name.find("_")+1 : ]
# Ricava la traduzione dell'input a seconda della lingua dei
# comandi utilizzata dall'entità
translation = translate_input(entity, input_word, "en")
# Preparare ed invia la tabella con la sintassi colorata del comando
output = '''<table class="mud">'''
for x, line in enumerate(syntax_string.split("\n")):
if not line.strip():
continue
# Esegue un replace di tutti i simboli di minore e maggiore che devono
# essere passati nella pagina come entità html
line = html_escape(line)
# Se trova uno spazio significa che ci sono argomenti aggiuntivi
# al comando normale che colora di verde più scuro
if " " in line:
line = line.replace(input_word, "[limegreen]%s[close][green]" % translation, 1)
else:
line = line.replace(input_word, "[limegreen]%s" % translation, 1)
line = '''<td>%s[close]</td></tr>''' % line
# Alla prima linea inserisce la dicitura di Sintassi, alle altre dello
# spazio per incolonnare correttamente
if x == 0:
line = '''<tr><td>[yellow]Sintassi[close]:</td>%s''' % line
else:
line = '''<tr><td></td>%s''' % line
output += line
output += '''</table>'''
return output
def send_channel_message(entity, message, personal):
if not message:
log.bug("message non è un parametro valido: %r" % message)
return
if personal not in (True, False):
log.bug("personal non è un parametro valido: %r" % personal)
return
# -------------------------------------------------------------------------
if message[0] == "\n":
message = message[1 : ]
if personal:
name = "[white]Tu[close]"
else:
name = entity.name
entity.send_output(message + '''<script>sendChannelMessage("%s", "%s", %s);</script>''' % (
html_escape(message.replace("<br>", "")), html_escape(name), str(personal).lower()))
def send_channel_message(entity, message, personal):
if not message:
log.bug("message non è un parametro valido: %r" % message)
return
if personal not in (True, False):
log.bug("personal non è un parametro valido: %r" % personal)
return
# -------------------------------------------------------------------------
if message[0] == "\n":
message = message[1:]
if personal:
name = "[white]Tu[close]"
else:
name = entity.name
entity.send_output(
message + '''<script>sendChannelMessage("%s", "%s", %s);</script>''' %
(html_escape(message.replace("<br>", "")), html_escape(name),
str(personal).lower()))
def get_connections(self, request, conn):
rows = []
for conn in connections.itervalues():
conn.request.received_headers = conn.request.requestHeaders.getAllRawHeaders() # For back compatibility
rows.append('''<tr>''')
rows.append('''<td>%s</td>''' % conn.get_id(conn))
rows.append('''<td>%s</td>''' % conn.logged_on)
if "user-agent" in conn.request.received_headers:
rows.append('''<td>%s</td>''' % conn.request.received_headers["user-agent"])
else:
log.bug("Connessione senza user-agent: %s" % conn.get_id())
rows.append('''<td>[red]Empty[close]</td>''')
rows.append('''<td>%s</td>''' % html_escape("%r" % conn.request))
rows.append('''<td>%d</td>''' % (conn.player.idle_seconds if conn.player else 0))
rows.append('''</tr>''')
return "".join(rows)
def get_connections(self, request, conn):
rows = []
for conn in connections.itervalues():
rows.append('''<tr>''')
rows.append('''<td>%s</td>''' % conn.get_id(conn))
rows.append('''<td>%s</td>''' % conn.logged_on)
if "user-agent" in conn.request.received_headers:
rows.append('''<td>%s</td>''' %
conn.request.received_headers["user-agent"])
else:
log.bug("Connessione senza user-agent: %s" % conn.get_id())
rows.append('''<td>[red]Empty[close]</td>''')
rows.append('''<td>%s</td>''' % html_escape("%r" % conn.request))
rows.append('''<td>%d</td>''' %
(conn.player.idle_seconds if conn.player else 0))
rows.append('''</tr>''')
return "".join(rows)
def msg(self, message, log_type=None, log_stack=True, write_on_file=True, send_output=True, use_blink=False):
"""
Invia un messaggio di log contenente errori o avvisi.
"""
if not message:
print("[log.bug] message non è un parametro valido: %r" % message)
return
# -------------------------------------------------------------------------
from src.enums import LOG
# Questa extract_stack è un collo di bottiglia prestazionale del Mud,
# tuttavia la sua utilità è indubbia e quindi fino a che Aarit non sarà
# maturissimo è inutile anche evitarla con qualche opzione di config.
# Ho deciso tuttavia di saltare il print della last_function relativa
# a tutti i messaggi di log reset, che sono quelli maggiormente inviati
stack = None
last_function = ""
last_function = ""
if not log_type or log_type.show_last_function:
stack = traceback.extract_stack()
last_function = str(stack[-3][2])
# Stampa il messaggio alla console e lo scrive sul file
if stack:
source_name = stack[-3][0].replace(os.getcwd(), "")
if "src" in source_name:
position = source_name.find("src")
source_name = source_name[position : ]
elif "data" in source_name:
position = source_name.find("data")
source_name = source_name[position : ]
source_line = stack[-3][1]
last_function = " (%s %s %s)" % (last_function, source_name, source_line)
# Rimuove i colori dal messaggio per una stampa a video maggiormente amica
from src.color import remove_colors
message = remove_colors(message)
# Invia il messaggio di log agli Admin del Mud
if send_output:
from src.database import database
if "players" in database and log_type.show_on_mud:
from src.utility import html_escape
for player in database["players"].itervalues():
if not player.game_request:
continue
if player.trust < log_type.trust and str(log_type.code) not in player.permissions:
continue
if log_type != LOG.ALWAYS and log_type not in player.account.show_logs and str(log_type.code) not in player.permissions:
continue
open_span = ""
close_span = ""
if use_blink:
open_span = "<span style='text-decoration: blink;'>"
close_span = "</span>"
player.send_output("<br>[magenta]%s%s %s%s[close]" % (
open_span, last_function.lstrip(), html_escape(message), close_span), avoid_log=True)
player.send_prompt()
# Visto che anche gli altri loop sono legati a questo, non c'è bisogno
# di controllarle tutti
from src.loops.aggressiveness import aggressiveness_loop
from src.loops.blob import blob_loop
from src.entitypes.corpse import decomposer_loop
from src.loops.digestion import digestion_loop
from src.fight import fight_loop
from src.game import game_loop
from src.maintenance import maintenance_loop
from src.behaviour import room_behaviour_loop
if (game_loop and game_loop.running
and maintenance_loop and maintenance_loop.running
and room_behaviour_loop and room_behaviour_loop.running
and fight_loop and fight_loop.running
and decomposer_loop and decomposer_loop.running
and aggressiveness_loop and aggressiveness_loop.running
and blob_loop and blob_loop.running
and digestion_loop and digestion_loop.running):
loop_status = "L"
else:
loop_status = "l"
now = datetime.datetime.now()
message = "%02d:%02d:%02d [%s] {%s}%s: %s" % (
now.hour,
now.minute,
now.second,
log_type,
loop_status,
last_function,
message)
log_file = None
if write_on_file and log_type.write_on_file:
log_path = "log/%d-%02d-%02d.log" % (now.year, now.month, now.day)
try:
log_file = open(log_path, "a")
except IOError:
print "Impossibile aprire il file %s in append" % log_path
log_file = None
else:
log_file.write("%s\n" % message)
# Questo viene fatto perché alcune console purtroppo non supportano
# i caratteri accentati e simili, viene così convertito l'accento
# nel famoso e muddoso accento apostrofato, quindi attenzione che
# in tal caso il messaggio nello stdout è falsato da quello originale
# nel qual caso si voglia cercarlo nel codice
if log_type.print_on_console:
from src.config import config
if config.ready and config.log_accents:
if "à" in message:
message = message.replace("à", "a'")
if "è" in message:
message = message.replace("è", "e'")
if "é" in message:
message = message.replace("é", "e'")
if "ì" in message:
message = message.replace("ì", "i'")
if "ò" in message:
message = message.replace("ò", "o'")
if "ù" in message:
message = message.replace("ù", "u'")
print(message)
# Se la tipologia di log non è un bug allora evita le informazioni di stack
if log_type != LOG.BUG:
log_stack = False
if stack and write_on_file and log_type.write_on_file and log_stack:
try:
traceback.print_stack(file=log_file)
traceback.print_stack(file=sys.stdout)
except IOError:
# (TT) non ho capito bene come mai mi fa così, ma semplicemente
# saltandolo mi evita di fare il traceback, cmq il log avviene
pass
if log_file:
log_file.close()
def send_log_content(self, request, conn, file):
# Scrive poco a poco il file di log che può raggiungere
# dimensioni ragguardevoli
for line in file:
request.write(convert_colors(html_escape(line)) + "<br>")
request.finish()
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 create_page(self, request, conn, table_name, sorted_by, searched_datas, reverse):
page = '''<h3>Lista del database %s:</h3>''' % table_name.capitalize()
# Se ci sono degli errori di richiesta o di account ritorna il messaggio adatto
if not searched_datas:
page += '''Non è stato trovato nessun dato.<br>'''
return page
# Altrimenti crea la pagina con la lista dei dati nell'ordine voluto
attributes = self.get_attributes(table_name)
if not sorted_by in attributes:
sorted_by = "primary_key"
# Se serve esegue il filtering delle aree
areas = []
if "areas" in request.args:
areas = request.args["areas"][0].split(",")
areas_arg = ""
if areas:
areas_arg = "&areas=%s" % ",".join(areas)
page += '''<form id="form_list_datas" name="form_list_datas" action="list_datas.html?table_name=%s&sorted_by=%s%s" method="post"><fieldset>''' % (
table_name, sorted_by, areas_arg)
page += '''<table border="1"><tr>'''
header_cells = []
for attr in attributes:
if attr == "primary_key":
header_cells.append('''<th nowrap='nowrap'><input type="submit" value="Filter ->" onclick="document.getElementById('form_list_datas').submit();" /><br>%s''' % create_demi_line(conn))
else:
checked = ""
if "column" in request.args:
if attr in request.args["column"]:
checked = '''checked="checked" '''
else:
continue
header_cells.append('''<th nowrap='nowrap'><input type="checkbox" name="column" value="%s" %s/><br>''' % (attr, checked))
arrow = ""
reverse_arg = ""
if attr == sorted_by:
if reverse:
arrow = ''' <img src="graphics/ascend.gif" width="10" height="5">'''
else:
arrow = ''' <img src="graphics/descend.gif" width="10" height="5">'''
reverse_arg = "&reverse=true"
header_cells.append('''<a href="list_datas.html?table_name=%s&sorted_by=%s%s%s">%s:</a>%s<br>%s''' % (
table_name, attr, reverse_arg, areas_arg, to_capitalized_words(attr), arrow, create_demi_line(conn)))
if attr == "primary_key":
header_cells.append('''<input type="submit" value="Cerca ->" onclick="document.getElementById('form_list_datas').submit();" /></th>''')
else:
value = ""
if "search_" + attr in request.args:
value = request.args["search_" + attr][0]
header_cells.append('''<input type="text" name="search_%s" maxlength="256" value="%s" /></th>''' % (attr, value))
page += "".join(header_cells) + '''</tr>'''
cells = []
for code, data in sort_datas(searched_datas, sorted_by, reverse):
if areas and code.split("_")[0] not in areas:
continue
cells.append('''<tr align="center">''')
for attr in attributes:
if attr == "primary_key":
cells.append('''<td><a href="edit_%s.html?code=%s">%s</a> (id: %d)</td>''' % (
table_name[0 : -1], code, code, id(data)))
else:
if "column" in request.args and attr not in request.args["column"]:
continue
if attr == "password":
attr_value = "****"
else:
attr_value = getattr(data, attr)
if type(attr_value) == datetime.datetime or type(attr_value) == datetime.date:
cells.append('''<td>%s</td>''' % pretty_date(past=attr_value))
elif type(data) == Command and attr == "timer":
total_use_count = data.get_total_use_count()
if total_use_count == 0:
cells.append('''<td>0</td>''')
else:
cells.append('''<td>%s</td>''' % (attr_value / total_use_count))
elif hasattr(attr_value, "PRIMARY_KEY") and attr_value.PRIMARY_KEY:
cells.append('''<td>%s</td>''' % getattr(attr_value, attr_value.PRIMARY_KEY))
elif attr_value and str(attr_value):
cells.append('''<td>%s</td>''' % html_escape(str(attr_value)))
else:
cells.append('''<td>%r</td>''' % attr_value)
cells.append('''</tr>''')
page += "".join(cells) + '''</table></fieldset></form>'''
return page
def send_log_content(self, request, conn, file):
# Scrive poco a poco il file di log che può raggiungere
# dimensioni ragguardevoli
for line in file:
request.write(convert_colors(html_escape(line)) + "<br>")
request.finish()