def roll(bot, trigger): """.dice XdY[vZ][+N][#COMMENT], rolls dice and reports the result. X is the number of dice. Y is the number of faces in the dice. Z is the number of lowest dice to be dropped from the result. N is the constant to be applied to the end result. Comment is for easily noting the purpose. """ # This regexp is only allowed to have one capture group, because having # more would alter the output of re.findall. dice_regexp = r"-?\d*[dD]-?\d+(?:[vV]-?\d+)?" # Get a list of all dice expressions, evaluate them and then replace the # expressions in the original string with the results. Replacing is done # using string formatting, so %-characters must be escaped. if not trigger.group(2): return bot.reply("No dice to roll.") arg_str_raw = trigger.group(2).split("#", 1)[0].strip() dice_expressions = re.findall(dice_regexp, arg_str_raw) arg_str = arg_str_raw.replace("%", "%%") arg_str = re.sub(dice_regexp, "%s", arg_str) def f(dice_expr): return _roll_dice(bot, dice_expr) dice = list(map(f, dice_expressions)) if None in dice: # Stop computing roll if there was a problem rolling dice. return def _get_eval_str(dice): return "(%d)" % (dice.get_sum(), ) def _get_pretty_str(dice): if dice.num <= 10: return dice.get_simple_string() elif dice.get_number_of_faces() <= 10: return dice.get_compressed_string() else: return "(...)" eval_str = arg_str % (tuple(map(_get_eval_str, dice))) pretty_str = arg_str % (tuple(map(_get_pretty_str, dice))) try: result = eval_equation(eval_str) except TypeError: bot.reply("The type of this equation is, apparently, not a string. " "How did you do that, anyway?") except ValueError: # As it seems that ValueError is raised if the resulting equation would # be too big, give a semi-serious answer to reflect on this. bot.reply("You roll %s: %s = very big" % (arg_str_raw, pretty_str)) return except (SyntaxError, eval_equation.Error): bot.reply("I don't know how to process that. " "Are the dice as well as the algorithms correct?") return bot.reply("You roll %s: %s = %d" % (arg_str_raw, pretty_str, result))
def roll(bot, trigger): """.dice XdY[vZ][+N], rolls dice and reports the result. X is the number of dice. Y is the number of faces in the dice. Z is the number of lowest dice to be dropped from the result. N is the constant to be applied to the end result. """ # This regexp is only allowed to have one captured group, because having # more would alter the output of re.findall. dice_regexp = r"-?\d*[dD]-?\d+(?:[vV]-?\d+)?" # Get a list of all dice expressions, evaluate them and then replace the # expressions in the original string with the results. Replacing is done # using string formatting, so %-characters must be escaped. if not trigger.group(2): return bot.reply("No dice to roll.") arg_str = trigger.group(2) dice_expressions = re.findall(dice_regexp, arg_str) arg_str = arg_str.replace("%", "%%") arg_str = re.sub(dice_regexp, "%s", arg_str) f = lambda dice_expr: _roll_dice(bot, dice_expr) dice = list(map(f, dice_expressions)) if None in dice: # Stop computing roll if there was a problem rolling dice. return def _get_eval_str(dice): return "(%d)" % (dice.get_sum(),) def _get_pretty_str(dice): if dice.num <= 10: return dice.get_simple_string() elif dice.get_number_of_faces() <= 10: return dice.get_compressed_string() else: return "(...)" eval_str = arg_str % (tuple(map(_get_eval_str, dice))) pretty_str = arg_str % (tuple(map(_get_pretty_str, dice))) try: result = eval_equation(eval_str) except TypeError: bot.reply("The type of this equation is, apparently, not a string. " + "How did you do that, anyway?") except ValueError: # As it seems that ValueError is raised if the resulting equation would # be too big, give a semi-serious answer to reflect on this. bot.reply("You roll %s: %s = very big" % ( trigger.group(2), pretty_str)) return except (SyntaxError, eval_equation.Error): bot.reply("I don't know how to process that. " + "Are the dice as well as the algorithms correct?") return bot.reply("You roll %s: %s = %d" % ( trigger.group(2), pretty_str, result))
def roll(bot, trigger): """.dice XdY[vZ][+N], rolls dice and reports the result. X is the number of dice. Y is the number of faces in the dice. Z is the number of lowest dice to be dropped from the result. N is the constant to be applied to the end result. """ # This regexp is only allowed to have one captured group, because having # more would alter the output of re.findall. dice_regexp = r"-?\d*[dD]-?\d+(?:[vV]-?\d+)?" # Get a list of all dice expressions, evaluate them and then replace the # expressions in the original string with the results. Replacing is done # using string formatting, so %-characters must be escaped. if not trigger.group(2): return bot.reply("No dice to roll.") arg_str = trigger.group(2) dice_expressions = re.findall(dice_regexp, arg_str) arg_str = arg_str.replace("%", "%%") arg_str = re.sub(dice_regexp, "%s", arg_str) f = lambda dice_expr: _roll_dice(bot, dice_expr) dice = list(map(f, dice_expressions)) if None in dice: # Stop computing roll if there was a problem rolling dice. return def _get_eval_str(dice): return "(%d)" % (dice.get_sum(),) def _get_pretty_str(dice): if dice.num <= 10: return dice.get_simple_string() elif dice.get_number_of_faces() <= 10: return dice.get_compressed_string() else: return "(...)" eval_str = arg_str % (tuple(map(_get_eval_str, dice))) pretty_str = arg_str % (tuple(map(_get_pretty_str, dice))) # Showing the actual error will hopefully give a better hint of what is # wrong with the syntax than a generic error message. try: result = eval_equation(eval_str) except Exception as e: bot.reply("SyntaxError, eval(%s), %s" % (eval_str, e)) return bot.reply("You roll %s: %s = %d" % ( trigger.group(2), pretty_str, result))
def roll(bot, trigger): """.dice XdY[vZ][+N], rolls dice and reports the result. X is the number of dice. Y is the number of faces in the dice. Z is the number of lowest dice to be dropped from the result. N is the constant to be applied to the end result. """ # This regexp is only allowed to have one captured group, because having # more would alter the output of re.findall. dice_regexp = r"-?\d*[dD]-?\d+(?:[vV]-?\d+)?" # Get a list of all dice expressions, evaluate them and then replace the # expressions in the original string with the results. Replacing is done # using string formatting, so %-characters must be escaped. if not trigger.group(2): return bot.reply("No dice to roll.") arg_str = trigger.group(2) dice_expressions = re.findall(dice_regexp, arg_str) arg_str = arg_str.replace("%", "%%") arg_str = re.sub(dice_regexp, "%s", arg_str) f = lambda dice_expr: _roll_dice(bot, dice_expr) dice = list(map(f, dice_expressions)) if None in dice: # Stop computing roll if there was a problem rolling dice. return def _get_eval_str(dice): return "(%d)" % (dice.get_sum(),) def _get_pretty_str(dice): if dice.num <= 10: return dice.get_simple_string() elif dice.get_number_of_faces() <= 10: return dice.get_compressed_string() else: return "(...)" eval_str = arg_str % (tuple(map(_get_eval_str, dice))) pretty_str = arg_str % (tuple(map(_get_pretty_str, dice))) # Showing the actual error will hopefully give a better hint of what is # wrong with the syntax than a generic error message. try: result = eval_equation(eval_str) except Exception as e: bot.reply("SyntaxError, eval(%s), %s" % (eval_str, e)) return bot.reply("You roll %s: %s = %d" % ( trigger.group(2), pretty_str, result))
def c(bot, trigger): """Evaluate some calculation.""" if not trigger.group(2): return bot.reply("Nothing to calculate.") # Account for the silly non-Anglophones and their silly radix point. eqn = trigger.group(2).replace(',', '.') try: result = eval_equation(eqn) result = "{:.10g}".format(result) except ZeroDivisionError: result = "Division by zero is not supported in this universe." except Exception as e: result = "{error}: {msg}".format(error=type(e), msg=e) bot.reply(result)
def c(bot, trigger): """Evaluate some calculation.""" if not trigger.group(2): return bot.reply("Nothing to calculate.") # Account for the silly non-Anglophones and their silly radix point. eqn = trigger.group(2).replace(',', '.') try: result = eval_equation(eqn) result = "{:.10g}".format(result) except ZeroDivisionError: result = "Division by zero is not supported in this universe." except Exception as e: result = "{error}: {msg}".format(error=type(e), msg=e) bot.reply(result)
def c(bot, trigger): """Evaluate some calculation.""" if not trigger.group(2): bot.reply('Nothing to calculate.') return # Account for the silly non-Anglophones and their silly radix point. eqn = trigger.group(2).replace(',', '.') try: result = eval_equation(eqn) result = "{:.10g}".format(result) except ZeroDivisionError: bot.reply('Division by zero is not supported in this universe.') return except SyntaxError: bot.reply('Invalid syntax') return bot.say(result)
def roll(trigger): """.dice XdY[vZ][+N], rolls dice and reports the result. X is the number of dice. Y is the number of faces in the dice. Z is the number of lowest dice to be dropped from the result. N is the constant to be applied to the end result. """ # This regexp is only allowed to have one captured group, because having # more would alter the output of re.findall. dice_regexp = r"-?\d*[dD]-?\d+(?:[vV]-?\d+)?" # Get a list of all dice expressions, evaluate them and then replace the # expressions in the original string with the results. Replacing is done # using string formatting, so %-characters must be escaped. if not trigger: return "额,你要我丢啥骰子?我没看到呢。" explain_str = '' total_str = trigger arg_str = total_str[0] if len(total_str) > 1: explain_str = ' ' + ' '.join(total_str[1:]) + ' ' if arg_str in ['d', 'D']: arg_str = 'd20' dform = [ 'd-', 'd+', 'd*', 'd/', 'D-', 'D+', 'D*', 'D/', 'd(', 'D(', ] if any(x in arg_str for x in dform): for i in dform: arg_str = arg_str.replace(i, i[0] + '20' + i[1]) dice_expressions = re.findall(dice_regexp, arg_str) arg_str = arg_str.replace("%", "%%") arg_str = re.sub(dice_regexp, "%s", arg_str) f = lambda dice_expr: _roll_dice(dice_expr) dice = list(map(f, dice_expressions)) if 'Error' in dice: # Stop computing roll if there was a problem rolling dice. return dice def _get_eval_str(dice): return "(%.10g)" % (dice.get_sum(), ) def _get_pretty_str(dice): if dice.num <= 10: return dice.get_simple_string() elif dice.get_number_of_faces() <= 10: return dice.get_compressed_string() else: return "(...)" eval_str = arg_str % (tuple(map(_get_eval_str, dice))) pretty_str = arg_str % (tuple(map(_get_pretty_str, dice))) # Showing the actual error will hopefully give a better hint of what is # wrong with the syntax than a generic error message. try: result = eval_equation(eval_str) result = float("{:.10g}".format(result)) except Exception as e: if "not implement" in '%s' % e: return "出错啦,没法计算 %s" % (eval_str) else: return "出错啦,没法计算 %s,原因:%s" % (eval_str, e) return "进行%s检定[%s]: %s=%s" % (explain_str, trigger[0], pretty_str, result)