def play_prop_sound(a, b, enemy=False): if enemy: base = 6000 else: base = 6100 ratio = divmod(a * 10, b)[0] exported.lyntin_command("#sound %s.ogg" % (ratio + base), internal=1)
def put(self, cmd, non_blocking=False): if non_blocking: exported.lyntin_command(cmd.command()) return if self._running: self._queue.put((cmd, time.time()))
def look_fortarget(args): global target text = args["data"] if target in text: if timed(): exported.lyntin_command("kill " + target) return args["data"]
def checkActions(self, text): """ Checks to see if text triggered any actions. Any resulting actions will get added as an InputEvent to the queue. @param text: the data coming from the mud to check for triggers @type text: string """ # FIXME - make sure this works even when lines are broken up. actionlist = self._actionlist if not actionlist: actionlist = [x for x in list(self._actions.values()) if x[6] not in self._disabled] actionlist.sort(key = lambda x:x[3]) self._actionlist = actionlist colorline = utils.filter_cm(text) nocolorline = ansi.filter_ansi(colorline) # go through all the lines in the data and see if we have # any matches for (action, actioncompiled, response, color, priority, onetime, tag) in actionlist: if color: match = actioncompiled.search(colorline) line = colorline else: match = actioncompiled.search(nocolorline) line = nocolorline if match: # for every match we figure out what the expanded response # is and add it as an InputEvent in the queue. the reason # we do a series of separate events rather than one big # event with ; separators is due to possible issues with # braces and such in malformed responses. # get variables from the action actionvars = get_ordered_vars(action) # fill in values for all the variables in the match varvals = {} for i in range(len(actionvars)): varvals[actionvars[i]] = match.group(i+1) # add special variables varvals['a'] = line.replace(';', '_') # fill in response variables from those that # matched on the trigger response = utils.expand_vars(response, varvals) # event.InputEvent(response, internal=1, ses=self._ses).enqueue() try: exported.lyntin_command(response, internal=1, session=self._ses) except: exported.write_traceback() if onetime and action in self._actions: del self._actions[action] self._actionlist = None # invalidate the list
def handle_timer(args): # tick tock global ticks for session in ticks.keys(): ticks[session] += 1 if ticks[session] >= 200: exported.write_message("You have been idle.", ses=session) exported.lyntin_command("#raw", internal=1, session=session) ticks[session] = 0
def loop_cmd(ses, args, input): """ Executes a given command replacing %0 in the command with the range of numbers specified in <from> and <to>. example: #loop {1,4} {reclaim %0.corpse} will execute: reclaim 1.corpse reclaim 2.corpse reclaim 3.corpse reclaim 4.corpse A better way to execute a command a number of times without regard to an index, would be: #4 {reclaim corpse} which will send "reclaim corpse" to the mud 5 times. category: commands """ loop = args["fromto"] command = args["comm"] # split it into parts looprange = loop.split(',') if len(looprange) != 2: exported.write_error("syntax: #loop <from,to> <command>", ses) return # remove trailing and leading whitespace and convert to ints # so we can use them in a range function ifrom = int(looprange[0].strip()) ito = int(looprange[1].strip()) # we need to handle backwards and forwards using the step # and need to adjust ito so the range is correctly bounded. if ifrom > ito: step = -1 else: step = 1 if ito > 0: ito = ito + step else: ito = ito - step for i in range(ifrom, ito, step): loopcommand = command.replace("%0", repr(i)) exported.lyntin_command(loopcommand, internal=1, session=ses)
def find_nmes(args): global targets,immd_tars,taking_inputs,exits,combat text= args['data'] if taking_inputs == 'yes': for tar in targets: if tar in text: immd_tars.append(tar) if ">" in text and taking_inputs == 'yes': exported.write_message('\n these are my current targs'+ str(immd_tars)) taking_inputs = 'no' if 'Exits' in text: found = re.search('\[ Exits: ([\w\s]+) \]',text) if found: exported.write_message('found exits are ' +found.group(0)) exits.extend(found.group(1).split()) health =re.search('(\d+/\d+)hp',text) if health: health = int(health.group(1).split('/')[0]) if 'Fighting:' in text: if random.choice(range(3)) == 1: exported.lyntin_command('kick' if random.choice('kb')== 'k' else 'bash') exported.lyntin_command('dirt' if random.choice('es') == 'e' else 'stun') if random.choice(range(4)) == 1: exported.lyntin_command('intimidate') if health < 300 : exported.write_message('trying to flee \n') exported.lyntin_command('fle') return args['data']
def timeUpdate(self, args): """ This gets called by the timer_hook in the engine every second. It goes through and executes all the events for this Lyntin tick as well as events who are supposed to execute at this seconds since the epoch or before. It also handles tossing events back in the schedule if they need repeating. """ tick = args["tick"] events = [] if self._events.has_key(tick): for mem in self._events[tick]: events.append(mem) del self._events[tick] self._current_tick = tick # we want to execute for this second and any previous seconds # that have been missed. sec = int(time.time()) keys = self._tevents.keys() keys = [mem for mem in keys if mem < sec] for key in keys: for mem in self._tevents[key]: events.append(mem) del self._tevents[key] # go through and execute all the events we've found for mem in events: if not mem._quiet: exported.write_message("Executing %r." % mem) if not callable(mem._cmd): exported.lyntin_command(mem._cmd, internal=1, session=mem._ses) else: try: mem._cmd(*mem._args, **mem._xargs) except: exported.write_traceback( "exception kicked up while trying to execute event.") # handles repeating events if mem._repeat == 1: self.addEvent(tick + mem._offset, mem, id=mem._id)
def _main(self): while self._running: try: cmd = self._queue.get() except KeyboardInterrupt: self._running = False self._queue.task_done() if not self._running: self._clear() break self._sent.append((cmd[0], cmd[1], time.time())) exported.lyntin_command(cmd[0].command(), internal=1) self.clear_sent()
def timeUpdate(self, args): """ This gets called by the timer_hook in the engine every second. It goes through and executes all the events for this Lyntin tick as well as events who are supposed to execute at this seconds since the epoch or before. It also handles tossing events back in the schedule if they need repeating. """ tick = args["tick"] events = [] if self._events.has_key(tick): for mem in self._events[tick]: events.append(mem) del self._events[tick] self._current_tick = tick # we want to execute for this second and any previous seconds # that have been missed. sec = int(time.time()) keys = self._tevents.keys() keys = [mem for mem in keys if mem < sec] for key in keys: for mem in self._tevents[key]: events.append(mem) del self._tevents[key] # go through and execute all the events we've found for mem in events: if not mem._quiet: exported.write_message("Executing %r." % mem) if not callable(mem._cmd): exported.lyntin_command(mem._cmd, internal=1, session=mem._ses) else: try: mem._cmd(*mem._args, **mem._xargs) except: exported.write_traceback("exception kicked up while trying to execute event.") # handles repeating events if mem._repeat == 1: self.addEvent(tick + mem._offset, mem, id=mem._id)
def receiver(self, sock): #session = exported.get_current_session() while True: try: data = sock.recv(4096) #session.handle_user_data(data.decode(settings.PROXY_ENCODING)) if len(data) == 0: exported.write_message( "SowMud Proxy: DEBUG: client lost in receive") return data = data.strip() exported.lyntin_command(data.decode(settings.PROXY_ENCODING)) except: exported.write_message( "SowMud Proxy: DEBUG: client lost in receive") self.remove_client(sock) return
def find_nmes(args): global exits_line,targets text= args['data'] if "[ Exits:" in text: exits_line = 1 if exits_line == 1: found = re.search('A (\w+ )',text) if found: targets.append(found.group(1)) if '>' in text: exported.write_message('my targets: '+''.join(targets)) exits_line = 0 if '[Fighting: ' in text: exported.lyntin_command('kick' if random.choice('kb')== 'k' else 'bash') return args['data']
def find_nmes(args): global conned,targets text= args['data'] if conned ==1: found = re.search('A|An (\w+ )',text) if found: targets.append(found.group(1)) exported.write_message(str(targets)) if targets: if '>' in text: exported.write_message('my targets: '+''.join(targets)) conned = 0 if '[Fighting: ' in text: exported.write_message('trying move') exported.lyntin_command('kick' if random.choice('kb')== 'k' else 'bash') return args['data']
def userfilter(self, args): """ user_filter_hook for handling incoming user data. """ ses = args["session"] internal = args["internal"] verbatim = args["verbatim"] text = args["dataadj"] if verbatim == 1: return text varexpansion = self.expand_command(ses, text) if varexpansion == text: return text else: exported.lyntin_command(varexpansion, 1, ses) return None
def recur(direc): global current,coords,no_go exported.write_message('going to move:'+direc) exported.lyntin_command(direc) if no_go: no_go = False with open('path_text.txt','a') as phile: phile.write(coords) coords.pop() return else: if direc == 'n': current = (coords[-1][0],coords[-1][1]+1) if direc == 'e': current = (coords[-1][0]+1,coords[-1][1]) if direc == 'w': current = (coords[-1][0]-1,coords[-1][1]) if direc == 's': current = (coords[-1][0],coords[-1][1]-1) for move in 'nesw': recur(move)
def userfilter(self, args): """ user_filter_hook function to check for speedwalking expansion. """ ses = args["session"] internal = args["internal"] verbatim = args["verbatim"] text = args["dataadj"] if not self._hashes.has_key(ses) or exported.get_config( "speedwalk", ses) == 0 or verbatim == 1: return text sdata = self._hashes[ses] if not sdata._dirs or not sdata._regexp or text in sdata._excludes \ or text in sdata._aliases or not sdata._regexp.match(text): return text swdirs = [] dir = num = "" for char in text: if char.isdigit(): num = num + char else: dir = dir + char if dir in sdata._dirs_available: if num: count = int(num) else: count = 1 for i in range(count): swdirs.append(sdata._dirs[dir]) dir = num = "" output = ";".join(swdirs) if output == text: return text else: # anything that gets recursed on should be recursed internally exported.lyntin_command(output, 1, ses) return None
def handle_from_mud(args): global sessions if not args['session'] in sessions: return if not sessions[args['session']]['matched_room']: if "speaks from the" not in args['data']: # let's not waste time on this regex if we're not looking for room name m = re.match(r'((o|\*) HP:\w+ MV:\w+ > |)\033\[36m(.*)\033\[0m$', args['data']) if m: # matched room name sessions[args['session']]['matched_room'] = True exported.lyntin_command("#var {room_name} {%s} quiet=true" % m.group(3), internal=1, session=args['session']) sessions[args['session']]['room_name'] = m.group(3) sessions[args['session']]['room_desc'] = "" sessions[args['session']]['room_exit'] = "" else: # now we should be looking for exits, anything before that is room desc m = re.match('^\\[ obvious exits:(.*)\\]$', args['data']) if m: # got the exit line sessions[args['session']]['room_exit'] = m.group(1).strip() sessions[args['session']]['room_desc'] = sessions[args['session']]['room_desc'].rstrip('\n') exported.lyntin_command("#var {room_desc} {%s} quiet=true" % sessions[args['session']]['room_desc'], internal=1, session=args['session']) exported.lyntin_command("#var {room_exits} {%s} quiet=true" % m.group(1).strip(), internal=1, session=args['session']) sessions[args['session']]['matched_room'] = False else: # it's a desc line sessions[args['session']]['room_desc'] += args['data']
def userfilter(self, args): """ user_filter_hook. """ # we check for aliases here--and if we find some, we # do the variable expansion and then recurse over the result ses = args["session"] internal = args["internal"] verbatim = args["verbatim"] text = args["dataadj"] if not self._aliasdata.has_key(ses) or verbatim == 1: return text aliasexpansion = self._aliasdata[ses].expand(text) if not aliasexpansion: return text else: aliasexpansion = utils.expand_placement_vars(text, aliasexpansion) exported.lyntin_command(aliasexpansion, 1, ses) return None
def userfilter(self, args): """ user_filter_hook. """ # we check for aliases here--and if we find some, we # do the variable expansion and then recurse over the result ses = args["session"] internal = args["internal"] verbatim = args["verbatim"] text = args["dataadj"] if ses not in self._aliasdata or verbatim == 1: return text aliasexpansion = self._aliasdata[ses].expand(text) if not aliasexpansion: return text else: aliasexpansion = utils.expand_placement_vars(text, aliasexpansion) exported.lyntin_command(aliasexpansion, 1, ses) return None
def userfilter(self, args): """ user_filter_hook function to check for speedwalking expansion. """ ses = args["session"] internal = args["internal"] verbatim = args["verbatim"] text = args["dataadj"] if not self._hashes.has_key(ses) or exported.get_config("speedwalk", ses) == 0 or verbatim == 1: return text sdata = self._hashes[ses] if not sdata._dirs or not sdata._regexp or text in sdata._excludes \ or text in sdata._aliases or not sdata._regexp.match(text): return text swdirs = [] dir = num = "" for char in text: if char.isdigit(): num = num + char else: dir = dir + char if dir in sdata._dirs_available: if num: count = int(num) else: count = 1 for i in range(count): swdirs.append(sdata._dirs[dir]) dir = num = "" output = ";".join(swdirs) if output == text: return text else: # anything that gets recursed on should be recursed internally exported.lyntin_command(output, 1, ses) return None
def get_targs(): global targets,conned if targets: exported.lyntin_command('kill '+ targets.pop()) else: exported.lyntin_command(random.choice('eswn')) exported.lyntin_command('con all') conned = 1
def if_cmd(ses, args, input): """ Allows you to do some boolean logic based on Lyntin variables or any Python expression. If this expression returns a non-false value, then the action will be performed otherwise the elseaction (if there is one) will be peformed. examples: #if {$myhpvar < 100} {#showme PANIC!} #if {$myhpvar < 100 && $myspvar < 100} {#showme PANIC!} #if {'$name' == 'Joe'} {#showme That joe is a jerk.} When you're comparing variable values with other strings, make sure to put them in quotes becuase variable expansion happens before the if command is evaluated. examples: WRONG: #if {$name == Joe} {#showme Joe is a jerk.} RIGHT: #if {'$name' == 'Joe'} {#showme Joe is a jerk.} category: commands """ # original if_cmd code contributed by Sebastian John expr = args["expr"] action = args["action"] elseaction = args["elseaction"] try: if eval(expr): exported.lyntin_command(action, 1, ses) elif elseaction: exported.lyntin_command(elseaction, 1, ses) except SyntaxError: exported.write_error("if: invalid syntax / syntax error.", ses) except Exception, e: exported.write_error("if: exception: %s" % e, ses)
def if_cmd(ses, args, input): """ Allows you to do some boolean logic based on Lyntin variables or any Python expression. If this expression returns a non-false value, then the action will be performed otherwise the elseaction (if there is one) will be peformed. examples: #if {$myhpvar < 100} {#showme PANIC!} #if {$myhpvar < 100 and $myspvar < 100} {#showme PANIC!} #if {'$name' == 'Joe'} {#showme That joe is a jerk.} When you're comparing variable values with other strings, make sure to put them in quotes becuase variable expansion happens before the if command is evaluated. examples: WRONG: #if {$name == Joe} {#showme Joe is a jerk.} RIGHT: #if {'$name' == 'Joe'} {#showme Joe is a jerk.} category: commands """ # original if_cmd code contributed by Sebastian John expr = args["expr"] action = args["action"] elseaction = args["elseaction"] try: if eval(expr): exported.lyntin_command(action, 1, ses) elif elseaction: exported.lyntin_command(elseaction, 1, ses) except SyntaxError: exported.write_error("if: invalid syntax / syntax error.", ses) except Exception, e: exported.write_error("if: exception: %s" % e, ses)
def do_command(self, e, cmd): if cmd == "disconnect": exported.lyntin_command("#zap") if cmd == "smile": exported.lyntin_command("улыбнуться", internal=1) if cmd == "connect": r = random.randint(0, 10) exported.lyntin_command("#session a{0} sowmud.ru 5555".format(r))
def get_targs(): global immd_tars,taking_inputs,exits if immd_tars: exported.lyntin_command('kill '+ immd_tars.pop()) exported.write_message('\nthese are current tars '+ str(immd_tars)) else: if exits: exported.lyntin_command(random.choice(exits)) taking_inputs = 'yes' exits = [] else: exported.lyntin_command(random.choice('eswn')) taking_inputs = 'yes'
def display_ingr(): global quest for k, v in quest.items(): mobs = ", ".join(v) exported.lyntin_command("gtell |{:^25}: {mobs}".format(k, mobs=mobs)) quest = {}
def main(defaultoptions={}): """ This parses the command line arguments and makes sure they're all valid, instantiates a ui, does some setup, spins off an engine thread, and goes into the ui's mainloop. @param defaultoptions: the boot options to use. we update the config.options dict with these options--this is the easiest way to override the ui, moduledir, datadir, et al from a Lyntin run script. @type defaultoptions: dict """ try: import sys, os, traceback, ConfigParser from lyntin import config, event, utils, exported from lyntin.ui import base import locale locale.setlocale(locale.LC_ALL, '') config.options.update(defaultoptions) # read through options and arguments optlist = utils.parse_args(sys.argv[1:]) for mem in optlist: if mem[0] == '--help': print constants.HELPTEXT sys.exit(0) elif mem[0] == '--version': print constants.VERSION sys.exit(0) elif mem[0] in ["--configuration", "-c"]: # ini files OVERRIDE the default options # they can provide multiple ini files, but each new # ini file will OVERRIDE the contents of the previous ini file # where the two files intersect. parser = ConfigParser.ConfigParser() parser.read([mem[1]]) newoptions = {} for s in parser.sections(): for o in parser.options(s): c = parser.get(s, o).split(",") if newoptions.has_key(o): newoptions[o] += c else: newoptions[o] = c config.options.update(newoptions) else: opt = mem[0] while opt.startswith("-"): opt = opt[1:] if len(opt) > 0: if config.options.has_key(opt): if type(config.options[opt]) is list: config.options[opt].append(mem[1]) else: config.options[opt] = mem[1] else: config.options[opt] = [mem[1]] for mem in ["datadir", "ui", "commandchar"]: if config.options.has_key(mem) and type(config.options[mem]) is list: config.options[mem] = config.options[mem][0] # if they haven't set the datadir via the command line, then # we go see if they have a HOME in their environment variables.... if not config.options["datadir"]: if os.environ.has_key("HOME"): config.options["datadir"] = os.environ["HOME"] config.options["datadir"] = utils.fixdir(config.options["datadir"]) def on_shutdown(): """ This gets called by the Python interpreter atexit. The reason we do shutdown stuff here is we're more likely to catch things here than we are to let everything cycle through the ShutdownEvent. This should probably get fixed up at some point in the future. """ if not hasattr(sys, 'frozen'): sys.stderr.write("goodbye.\n") #exported.hook_spam("shutdown_hook", {}) import atexit atexit.register(on_shutdown) # instantiate the engine Engine.instance = Engine() exported.myengine = Engine.instance Engine.instance._setupConfiguration() # instantiate the ui uiinstance = None try: uiname = str(config.options['ui']) modulename = uiname + "ui" uiinstance = base.get_ui(modulename) if not uiinstance: raise ValueError("No ui instance.") except Exception, e: print "Cannot start '%s': %s" % (uiname, e) traceback.print_exc() sys.exit(0) Engine.instance.setUI(uiinstance) # do some more silly initialization stuff # adds the .lyntinrc file to the readfile list if it exists. if config.options["datadir"]: lyntinrcfile = config.options["datadir"] + ".lyntinrc" if os.path.exists(lyntinrcfile): # we want the .lyntinrc file read in first, so then other # files can overwrite the contents therein config.options['readfile'].insert(0, lyntinrcfile) # import modules listed in modulesinit exported.write_message("Loading Lyntin modules.") try: import lyntin.modules lyntin.modules.load_modules() except: exported.write_traceback("Modules did not load correctly.") sys.exit(1) commandchar = Engine.instance._managers["config"].get("commandchar") # handle command files for mem in config.options['readfile']: exported.write_message("Reading in file " + mem) # we have to escape windows os separators because \ has a specific # meaning in the argparser mem = mem.replace("\\", "\\\\") exported.lyntin_command("%sread %s" % (commandchar, mem), internal=1) # spam the startup hook exported.hook_spam("startup_hook", {}) # we're done initialization! exported.write_message(constants.STARTUPTEXT) Engine.instance.writePrompt() engine_thread = Engine.instance.startthread("engine", Engine.instance.runengine) timer_thread = Engine.instance.startthread("timer", Engine.instance.runtimer) try: Engine.instance._ui.runui() finally: if not hasattr(sys, 'frozen'): sys.stderr.write("Shutting down...") event.ShutdownEvent().enqueue() engine_thread.join(10) timer_thread.join(10)
def main(defaultoptions={}): """ This parses the command line arguments and makes sure they're all valid, instantiates a ui, does some setup, spins off an engine thread, and goes into the ui's mainloop. @param defaultoptions: the boot options to use. we update the config.options dict with these options--this is the easiest way to override the ui, moduledir, datadir, et al from a Lyntin run script. @type defaultoptions: dict """ try: import sys, os, traceback, ConfigParser from lyntin import config, event, utils, exported from lyntin.ui import base import locale locale.setlocale(locale.LC_ALL, '') config.options.update(defaultoptions) # read through options and arguments optlist = utils.parse_args(sys.argv[1:]) for mem in optlist: if mem[0] == '--help': print constants.HELPTEXT sys.exit(0) elif mem[0] == '--version': print constants.VERSION sys.exit(0) elif mem[0] in ["--configuration", "-c"]: # ini files OVERRIDE the default options # they can provide multiple ini files, but each new # ini file will OVERRIDE the contents of the previous ini file # where the two files intersect. parser = ConfigParser.ConfigParser() parser.read([mem[1]]) newoptions = {} for s in parser.sections(): for o in parser.options(s): c = parser.get(s, o).split(",") if newoptions.has_key(o): newoptions[o] += c else: newoptions[o] = c config.options.update(newoptions) else: opt = mem[0] while opt.startswith("-"): opt = opt[1:] if len(opt) > 0: if config.options.has_key(opt): if type(config.options[opt]) is list: config.options[opt].append(mem[1]) else: config.options[opt] = mem[1] else: config.options[opt] = [mem[1]] for mem in ["datadir", "ui", "commandchar"]: if config.options.has_key(mem) and type( config.options[mem]) is list: config.options[mem] = config.options[mem][0] # if they haven't set the datadir via the command line, then # we go see if they have a HOME in their environment variables.... if not config.options["datadir"]: if os.environ.has_key("HOME"): config.options["datadir"] = os.environ["HOME"] config.options["datadir"] = utils.fixdir(config.options["datadir"]) def on_shutdown(): """ This gets called by the Python interpreter atexit. The reason we do shutdown stuff here is we're more likely to catch things here than we are to let everything cycle through the ShutdownEvent. This should probably get fixed up at some point in the future. """ sys.stderr.write("goodbye.\n") #exported.hook_spam("shutdown_hook", {}) import atexit atexit.register(on_shutdown) # instantiate the engine Engine.instance = Engine() exported.myengine = Engine.instance Engine.instance._setupConfiguration() # instantiate the ui uiinstance = None try: uiname = str(config.options['ui']) modulename = uiname + "ui" uiinstance = base.get_ui(modulename) if not uiinstance: raise ValueError("No ui instance.") except Exception, e: print "Cannot start '%s': %s" % (uiname, e) traceback.print_exc() sys.exit(0) Engine.instance.setUI(uiinstance) # do some more silly initialization stuff # adds the .lyntinrc file to the readfile list if it exists. if config.options["datadir"]: lyntinrcfile = config.options["datadir"] + ".lyntinrc" if os.path.exists(lyntinrcfile): # we want the .lyntinrc file read in first, so then other # files can overwrite the contents therein config.options['readfile'].insert(0, lyntinrcfile) # import modules listed in modulesinit exported.write_message("Loading Lyntin modules.") try: import modules.__init__ modules.__init__.load_modules() except: exported.write_traceback("Modules did not load correctly.") sys.exit(1) # spam the startup hook exported.hook_spam("startup_hook", {}) commandchar = Engine.instance._managers["config"].get("commandchar") # handle command files for mem in config.options['readfile']: exported.write_message("Reading in file " + mem) # we have to escape windows os separators because \ has a specific # meaning in the argparser mem = mem.replace("\\", "\\\\") exported.lyntin_command("%sread %s" % (commandchar, mem), internal=1) # we're done initialization! exported.write_message(constants.STARTUPTEXT) Engine.instance.writePrompt() engine_thread = Engine.instance.startthread("engine", Engine.instance.runengine) timer_thread = Engine.instance.startthread("timer", Engine.instance.runtimer) try: Engine.instance._ui.runui() finally: sys.stderr.write("Shutting down...") event.ShutdownEvent().enqueue() engine_thread.join(10) timer_thread.join(10)
def remove(ses,args,input): global module exported.lyntin_command('-unload '+module)
def handleinput(self, line, internal=0): self._append([(line + "\n", self.attr_user_)]) if internal: exported.lyntin_command(line, internal=1) else: base.BaseUI.handleinput(self, line)
def join_cir(ses,args,input): name = args ['value'] exported.lyntin_command('#session {} localhost 4000'.format(name))
def select_and_move(): movement_choice = random.choice(movement_list) exported.write_message(movement_choice) exported.lyntin_command('exits') # start_wander = time.time() exported.lyntin_command(movement_choice)
def find_nmes(args): global exits_line,targets text= args['data'] if "[ Exits:" in text: exits_line = 1 if exits_line == 1: found = re.search('[A|An] (\w+) ',text) if found: exported.write_message(targets) targets.append(found.group(1)) if '>' in text: exits_line = 0 try: if health< 500: exported.lyntin_command('treat') except: pass health =re.search('(\d+/\d+)hp',text) if health: health = int(health.group(1).split('/')[0]) if 'Fighting:' in text: if random.choice(range(7)) == 1: exported.lyntin_command('kick' if random.choice('kb')== 'k' else 'bash') exported.lyntin_command('dirt' if random.choice('es') == 'e' else 'stun') if random.choice(range(7)) == 1: exported.lyntin_command('intimidate') if health < 300 : exported.write_message('trying to flee \n') exported.lyntin_command('flee') if health < 100 : exported.lyntin_command('fle') return args['data']
def go_getem(ses,args,input): if presence == 'yes' and target != None: exported.lyntin_command('kill '+target)
f.close() except Exception, e: exported.write_error( "read: file %s cannot be opened.\n%s" % (filename, e), ses) return contents = [m for m in contents if len(m.strip()) > 0] if len(contents) == 0: exported.write_message("read: %s had no data." % filename, ses) return c = exported.get_config("commandchar") if not contents[0].startswith(c): exported.lyntin_command("%sconfig commandchar %s" % (c, contents[0][0]), internal=1, session=ses) command = "" continued = 0 # FIXME - should this be a config setting? esc = "\\" for mem in contents: mem = mem.strip() if len(mem) > 0: # handle multi-line commands if mem.endswith(esc): mem = mem.rstrip(esc) continued = 1 else:
def handleinput(self, line, internal=0): self._append( [ (line+"\n", self.attr_user_) ] ) if internal: exported.lyntin_command(line, internal=1) else: base.BaseUI.handleinput(self, line)
def ifvar_cmd(session, args, input): if args['variable'] in session._vars.keys(): exported.lyntin_command(args['action'], 1, session) elif args['elseaction']: exported.lyntin_command(args['elseaction'], 1, session)
def reconnect(self, args): prev_ses = args['session'].getName() self.turn_off() exported.write_message("disconnected from SoW, {0}".format(prev_ses)) exported.lyntin_command("#session a{0} sowmud.ru 5555".format(prev_ses))
def timerget(args): tick = args["tick"] if tick: if tick % random.choice(range(4, 10)) == 0: exported.lyntin_command(random.choice("eswn")) return tick
def commo_cmd(session, args, input): if args['action'] == "add": if not session in sessions: f = open(config.options['datadir'] + session.getName() + '-comms', 'w') sessions[session] = f exported.lyntin_command("#showme Session %s now monitored by comms logger" % session.getName(), True, session) else: exported.lyntin_command("#showme Session %s already monitored by comms logger" % session.getName(), True, session) elif args['action'] == "remove": if session in sessions: sessions[session].close() del sessions[session] exported.lyntin_command("#showme Session %s no longer monitored by comms logger" % session.getName(), True, session) else: exported.lyntin_command("#showme Session %s isn't monitored by comms logger" % session.getName(), True, session) elif args['action'] == "": if len(sessions): exported.lyntin_command("#showme Sessions monitored by comms logger:", True, session) for s in sessions: exported.lyntin_command("#showme %s" % s.getName(), True, session) else: exported.lyntin_command("#showme No sessions currently monitored by comms logger", True, session)
def execute(self): """ Execute.""" if not self._internal: exported.write_user_data(self._input) exported.lyntin_command(self._input, internal=self._internal, session=self._ses)
f = open(filename, "r") contents = f.readlines() f.close() except Exception, e: exported.write_error("read: file %s cannot be opened.\n%s" % (filename, e), ses) return contents = [m for m in contents if len(m.strip()) > 0] if len(contents) == 0: exported.write_message("read: %s had no data." % filename, ses) return c = exported.get_config("commandchar") if not contents[0].startswith(c): exported.lyntin_command("%sconfig commandchar %s" % (c, contents[0][0]), internal=1, session=ses) command = "" continued = 0 # FIXME - should this be a config setting? esc = "\\" for mem in contents: mem = mem.strip() if len(mem) > 0: # handle multi-line commands if mem.endswith(esc): mem = mem.rstrip(esc) continued = 1 else: continued = 0
def test_load(ses,args,input): global module module = args['value'] exported.lyntin_command('-load '+ module)
def checkActions(self, text): """ Checks to see if text triggered any actions. Any resulting actions will get added as an InputEvent to the queue. @param text: the data coming from the mud to check for triggers @type text: string """ # FIXME - make sure this works even when lines are broken up. actionlist = self._actionlist if not actionlist: actionlist = filter(lambda x: not self._disabled.has_key(x[6]), self._actions.values()) actionlist.sort(key=lambda i: i[3]) self._actionlist = actionlist colorline = utils.filter_cm(text) nocolorline = ansi.filter_ansi(colorline) # go through all the lines in the data and see if we have # any matches for (action, actioncompiled, response, color, priority, onetime, tag) in actionlist: if color: match = actioncompiled.search(colorline) line = colorline else: match = actioncompiled.search(nocolorline) line = nocolorline if match: # for every match we figure out what the expanded response # is and add it as an InputEvent in the queue. the reason # we do a series of separate events rather than one big # event with ; separators is due to possible issues with # braces and such in malformed responses. # fill in values for all the variables in the match varvals = {} if match.lastindex is not None: if action.startswith('r['): for i in xrange(match.lastindex): varvals[str(i+1)] = match.group(i+1) else: # get variables from the action actionvars = get_ordered_vars(action) for i in xrange(len(actionvars)): varvals[actionvars[i]] = match.group(i+1) # add special variables varvals['a'] = line.replace(';', '_') # fill in response variables from those that # matched on the trigger response = utils.expand_vars(response, varvals) # event.InputEvent(response, internal=1, ses=self._ses).enqueue() try: exported.lyntin_command(response, internal=1, session=self._ses) except: exported.write_traceback() if onetime and self._actions.has_key(action): del self._actions[action] self._actionlist = None # invalidate the list
def read_cmd(ses, args, input): """ Reads in a file running each line as a Lyntin command. This is the opposite of #write which allows you to save session settings and restore them using #read. You can also read in via the commandline when you start Lyntin: lyntin --read 3k And read can handle HTTP urls: lyntin --read http://lyntin.sourceforge.net/lyntinrc #read http://lyntin.sourceforge.net/lyntinrc Note: the first non-whitespace char is used to set the Lyntin command character. If you use non Lyntin commands in your file, make sure the first one is a command char. If not, use #nop . It will skip blank lines. If you don't specify a directory, Lyntin will look for the file in your datadir. category: commands """ filename = args["filename"] import os if os.sep not in filename and not filename.startswith("http://"): filename = config.options["datadir"] + filename if filename.startswith("~"): filename = os.path.expanduser(filename) try: # http reading contributed by Sebastian John if filename.startswith("http://"): contents = utils.http_get(filename).split("\n") else: f = open(filename, "rb") contents = f.readlines() f.close() except Exception as e: exported.write_error( "read: file %s cannot be opened.\n%s" % (filename, e), ses) return contents = [x.decode("utf-8") for x in contents] contents = [m for m in contents if len(m.strip()) > 0] if len(contents) == 0: exported.write_message("read: %s had no data." % filename, ses) return c = exported.get_config("commandchar") if not contents[0].startswith(c): exported.lyntin_command("%sconfig commandchar %s" % (c, contents[0][0]), internal=1, session=ses) command = "" continued = 0 # FIXME - should this be a config setting? esc = "\\" for mem in contents: mem = mem.strip() if len(mem) > 0: # handle multi-line commands if mem.endswith(esc): mem = mem.rstrip(esc) continued = 1 else: continued = 0 command = command + mem if not continued: exported.lyntin_command(command, internal=1, session=ses) command = "" exported.write_message("read: file %s read." % filename, ses)
def treat(): exported.lyntin_command('-4 treat')
def loop_cmd(ses, args, input): """ Executes a given command replacing %0 in the command with the range of numbers specified in <from> and <to>. example: #loop {1,4} {reclaim %0.corpse} will execute: reclaim 1.corpse reclaim 2.corpse reclaim 3.corpse reclaim 4.corpse Additionally, it can iterate over a comma-separated string of items: example: #loop {joe,harry,fred,pete} {say hi, %0.} range=no will execute: say hi, joe. say hi, harry. say hi, fred. say hi, pete. A better way to execute a command a number of times without regard to an index, would be: #4 {reclaim corpse} which will send "reclaim corpse" to the mud 5 times. category: commands """ loop = args["fromto"] command = args["comm"] r = args["range"] # split it into parts loopitems = loop.split(',') if r: if len(loopitems) != 2: exported.write_error("syntax: #loop <from,to> <command>", ses) return # remove trailing and leading whitespace and convert to ints # so we can use them in a range function ifrom = int(loopitems[0].strip()) ito = int(loopitems[1].strip()) # we need to handle backwards and forwards using the step # and need to adjust ito so the range is correctly bounded. if ifrom > ito: step = -1 else: step = 1 if ito > 0: ito = ito + step else: ito = ito - step loopitems = list(range(ifrom, ito, step)) loopitems = [repr(m) for m in loopitems] # for i in range(ifrom, ito, step): # loopcommand = command.replace("%0", repr(i)) # exported.lyntin_command(loopcommand, internal=1, session=ses) for mem in loopitems: mem = mem.strip() loopcommand = command.replace("%0", mem) exported.lyntin_command(loopcommand, internal=1, session=ses)