def tell(user, message, delay=0, lock=None, prefix=''): """Send a server message to user. Note: Splits multiline messages. See prefix, below. Optional args: delay: Wait delay seconds before sending message. Useful mainly with lock. See below. lock: Until message sent (see delay) allow no new messages with the same user and lock value. Generally speaking, expected to be a string. But it doesn't really matter. prefix: Add given prefix to every line sent, eg '<server>: '. Returns bool of whether message was sent (see lock). Note: Apart from delay and lock args, this function acts like helpers.tell() """ message = unicode(message) tell_fn = lambda: helpers.tell(user, message, prefix=prefix) if delay: try: schedule.check(lock) except KeyError: schedule.register(delay, tell_fn, key=lock) else: return False else: tell_fn() return True
def display(user, menu_text, options, exit_callback, timeout=None):
"""Display given menu to player. Menu format is as follows:
menu_text: The main "body" text of the menu
options: A list of tuples ("option text", option_callback). option_callback is called if the option is picked.
Alternately, setting options=('prompt', callback) asks the user for a string instead. Note the strings 'exit' and 'again' are impossible.
exit_callback: Called if the player tries to exit the menu.
timeout: Optional. Either a timeout in (float,int) seconds, or a tuple (timeout, callback),
where the callback is called after timeout. Else the exit_callback is called.
If not given, has a default timeout menus.DEFAULT_TIMEOUT
Callback functions act as follows:
Should take args (user, response)
Response will generally be the number they picked to pick the given callback option,
but will be 'exit' for the exit_callback, None if it timed out, or the full response if 'prompt' was given.
Should return either None (player no longer in a menu),
or a tuple (menu_text, options, exit_callback, timeout) as per this function's args.
Note that timeout is still optional.
If another menu is currently active, raises a menus.MenuLockError
"""
if hasattr(user, 'menu') and user.menu is not None:
raise MenuLockError(user, user.menu)
if timeout is None:
timeout = DEFAULT_TIMEOUT
if type(timeout) is not tuple:
timeout = (timeout, exit_callback)
user.menu = (menu_text, options, exit_callback, timeout)
tell_menu(user, user.menu)
schedule.register(timeout[0], lambda: on_timeout(user), key=('menu', user))
def schedule(user_name, cur_item, is_mod, is_owner, websocket): cmd = "schedule" if not is_mod or not is_owner: return None # Mod/owner only if len(cur_item) < 3: return usage.prepCmd(user_name, "schedule", is_mod, is_owner) cmd_cmd = cur_item[1] if cmd_cmd.lower() == "add": if len(cur_item) >= 3: text = cur_item[2:] response = schedule_mod.register(text, websocket) else: return "Usage: !schedule add MESSAGEHERE" elif cmd_cmd.lower() == "remove": try: schedule_id = int(cur_item[2]) except: return "Usage: !schedule remove MESSAGEIDHERE" response = schedule_mod.msg_rm(schedule_id, websocket) elif cmd_cmd.lower() == "update": try: schedule_id = int(cur_item[2]) except: return "Usage: !schedule update MESSAGEIDHERE MESSAGETEXTHERE" if len(cur_item) >= 3: text = cur_item[3:] response = schedule_mod.edit_msg(text, schedule_id, websocket) else: return "Usage: !schedule update MESSAGEIDHERE MESSAGETEXTHERE" else: return usage.prepCmd(user_name, "schedule", is_mod, is_owner) return response
INTERVAL = 1 # Seconds between refresh
def on_start():
load_bans()
def load_bans():
global bans
try:
new_bans = open(ban_file, 'rU').read().split('\n')
except IOError, ex:
if bans is None:
raise
logging.warning("Failed to refresh ban file:", exc_info=True)
else:
bans = new_bans
schedule.register(INTERVAL, load_bans) # Repeat self after INTERVAL
def on_packet(packet, user, to_server):
if to_server and packet.name() == 'Handshake':
ip, port = user.addr
if ip in bans:
packet = Packet("Disconnect", reason="No U")
send_packet(packet, user, False)
return []
return packet
