changing dice to roll
This commit is contained in:
NikolajDanger
545
funcs/roll/dice.py
Normal file
545
funcs/roll/dice.py
Normal file
@ -0,0 +1,545 @@
|
||||
import logging
|
||||
import random
|
||||
import re
|
||||
import traceback
|
||||
from heapq import nlargest, nsmallest
|
||||
from math import floor
|
||||
from re import IGNORECASE
|
||||
|
||||
import numexpr
|
||||
|
||||
import errors
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
VALID_OPERATORS = 'k|rr|ro|mi|ma|ra|e|p'
|
||||
VALID_OPERATORS_ARRAY = VALID_OPERATORS.split('|')
|
||||
VALID_OPERATORS_2 = re.compile('|'.join(["({})".format(i) for i in VALID_OPERATORS_ARRAY]))
|
||||
DICE_PATTERN = re.compile(
|
||||
r'^\s*(?:(?:(\d*d\d+)(?:(?:' + VALID_OPERATORS + r')(?:[lh<>]?\d+))*|(\d+)|([-+*/().=])?)\s*(\[.*\])?)(.*?)\s*$',
|
||||
IGNORECASE)
|
||||
|
||||
|
||||
def list_get(index, default, l):
|
||||
try:
|
||||
a = l[index]
|
||||
except IndexError:
|
||||
a = default
|
||||
return a
|
||||
|
||||
|
||||
def roll(rollStr, adv: int = 0, rollFor='', inline=False, double=False, show_blurbs=True, **kwargs):
|
||||
roller = Roll()
|
||||
result = roller.roll(rollStr, adv, rollFor, inline, double, show_blurbs, **kwargs)
|
||||
return result
|
||||
|
||||
|
||||
def get_roll_comment(rollStr):
|
||||
"""Returns: A two-tuple (dice without comment, comment)"""
|
||||
try:
|
||||
comment = ''
|
||||
no_comment = ''
|
||||
dice_set = re.split('([-+*/().=])', rollStr)
|
||||
dice_set = [d for d in dice_set if not d in (None, '')]
|
||||
log.debug("Found dice set: " + str(dice_set))
|
||||
for index, dice in enumerate(dice_set):
|
||||
match = DICE_PATTERN.match(dice)
|
||||
log.debug("Found dice group: " + str(match.groups()))
|
||||
no_comment += dice.replace(match.group(5), '')
|
||||
if match.group(5):
|
||||
comment = match.group(5) + ''.join(dice_set[index + 1:])
|
||||
break
|
||||
|
||||
return no_comment, comment
|
||||
except:
|
||||
pass
|
||||
return rollStr, ''
|
||||
|
||||
|
||||
class Roll(object):
|
||||
def __init__(self, parts=None):
|
||||
if parts is None:
|
||||
parts = []
|
||||
self.parts = parts
|
||||
|
||||
def get_crit(self):
|
||||
"""Returns: 0 for no crit, 1 for 20, 2 for 1."""
|
||||
try:
|
||||
crit = next(p.get_crit() for p in self.parts if isinstance(p, SingleDiceGroup))
|
||||
except StopIteration:
|
||||
crit = 0
|
||||
return crit
|
||||
|
||||
def get_total(self):
|
||||
"""Returns: int"""
|
||||
return numexpr.evaluate(''.join(p.get_eval() for p in self.parts if not isinstance(p, Comment)))
|
||||
|
||||
# # Dice Roller
|
||||
def roll(self, rollStr, adv: int = 0, rollFor='', inline=False, double=False, show_blurbs=True, **kwargs):
|
||||
try:
|
||||
if '**' in rollStr:
|
||||
raise errors.InvalidArgument("Exponents are currently disabled.")
|
||||
self.parts = []
|
||||
# split roll string into XdYoptsSel [comment] or Op
|
||||
# set remainder to comment
|
||||
# parse each, returning a SingleDiceResult
|
||||
dice_set = re.split('([-+*/().=])', rollStr)
|
||||
dice_set = [d for d in dice_set if not d in (None, '')]
|
||||
log.debug("Found dice set: " + str(dice_set))
|
||||
for index, dice in enumerate(dice_set):
|
||||
match = DICE_PATTERN.match(dice)
|
||||
log.debug("Found dice group: " + str(match.groups()))
|
||||
# check if it's dice
|
||||
if match.group(1):
|
||||
roll = self.roll_one(dice.replace(match.group(5), ''), adv)
|
||||
self.parts.append(roll)
|
||||
# or a constant
|
||||
elif match.group(2):
|
||||
self.parts.append(Constant(value=int(match.group(2)), annotation=match.group(4)))
|
||||
# or an operator
|
||||
elif not match.group(5):
|
||||
self.parts.append(Operator(op=match.group(3), annotation=match.group(4)))
|
||||
|
||||
if match.group(5):
|
||||
self.parts.append(Comment(match.group(5) + ''.join(dice_set[index + 1:])))
|
||||
break
|
||||
|
||||
# calculate total
|
||||
crit = self.get_crit()
|
||||
try:
|
||||
total = self.get_total()
|
||||
except SyntaxError:
|
||||
raise errors.InvalidArgument("No dice found to roll.")
|
||||
rolled = ' '.join(str(res) for res in self.parts if not isinstance(res, Comment))
|
||||
if rollFor is '':
|
||||
rollFor = ''.join(str(c) for c in self.parts if isinstance(c, Comment))
|
||||
# return final solution
|
||||
if not inline:
|
||||
# Builds end result while showing rolls
|
||||
reply = ' '.join(
|
||||
str(res) for res in self.parts if not isinstance(res, Comment)) + '\n**Total:** ' + str(
|
||||
floor(total))
|
||||
skeletonReply = reply
|
||||
rollFor = rollFor if rollFor is not '' else 'Result'
|
||||
reply = '**{}:** '.format(rollFor) + reply
|
||||
if show_blurbs:
|
||||
if adv == 1:
|
||||
reply += '\n**Rolled with Advantage**'
|
||||
elif adv == -1:
|
||||
reply += '\n**Rolled with Disadvantage**'
|
||||
if crit == 1:
|
||||
critStr = "\n_**Critical Hit!**_ "
|
||||
reply += critStr
|
||||
elif crit == 2:
|
||||
critStr = "\n_**Critical Fail!**_ "
|
||||
reply += critStr
|
||||
else:
|
||||
# Builds end result while showing rolls
|
||||
reply = ' '.join(str(res) for res in self.parts if not isinstance(res, Comment)) + ' = `' + str(
|
||||
floor(total)) + '`'
|
||||
skeletonReply = reply
|
||||
rollFor = rollFor if rollFor is not '' else 'Result'
|
||||
reply = '**{}:** '.format(rollFor) + reply
|
||||
if show_blurbs:
|
||||
if adv == 1:
|
||||
reply += '\n**Rolled with Advantage**'
|
||||
elif adv == -1:
|
||||
reply += '\n**Rolled with Disadvantage**'
|
||||
if crit == 1:
|
||||
critStr = "\n_**Critical Hit!**_ "
|
||||
reply += critStr
|
||||
elif crit == 2:
|
||||
critStr = "\n_**Critical Fail!**_ "
|
||||
reply += critStr
|
||||
reply = re.sub(' +', ' ', reply)
|
||||
skeletonReply = re.sub(' +', ' ', str(skeletonReply))
|
||||
return DiceResult(result=int(floor(total)), verbose_result=reply, crit=crit, rolled=rolled,
|
||||
skeleton=skeletonReply, raw_dice=self)
|
||||
except Exception as ex:
|
||||
if not isinstance(ex, (SyntaxError, KeyError, errors.AvraeException)):
|
||||
log.error('Error in roll() caused by roll {}:'.format(rollStr))
|
||||
traceback.print_exc()
|
||||
return DiceResult(verbose_result="Invalid input: {}".format(ex))
|
||||
|
||||
def roll_one(self, dice, adv: int = 0):
|
||||
result = SingleDiceGroup()
|
||||
result.rolled = []
|
||||
# splits dice and comments
|
||||
split = re.match(r'^([^\[\]]*?)\s*(\[.*\])?\s*$', dice)
|
||||
dice = split.group(1).strip()
|
||||
annotation = split.group(2)
|
||||
result.annotation = annotation if annotation is not None else ''
|
||||
# Recognizes dice
|
||||
obj = re.findall('\d+', dice)
|
||||
obj = [int(x) for x in obj]
|
||||
numArgs = len(obj)
|
||||
|
||||
ops = []
|
||||
if numArgs == 1:
|
||||
if not dice.startswith('d'):
|
||||
raise errors.InvalidArgument('Please pass in the value of the dice.')
|
||||
numDice = 1
|
||||
diceVal = obj[0]
|
||||
if adv is not 0 and diceVal == 20:
|
||||
numDice = 2
|
||||
ops = ['k', 'h1'] if adv is 1 else ['k', 'l1']
|
||||
elif numArgs == 2:
|
||||
numDice = obj[0]
|
||||
diceVal = obj[-1]
|
||||
if adv is not 0 and diceVal == 20:
|
||||
ops = ['k', 'h' + str(numDice)] if adv is 1 else ['k', 'l' + str(numDice)]
|
||||
numDice = numDice * 2
|
||||
else: # split into xdy and operators
|
||||
numDice = obj[0]
|
||||
diceVal = obj[1]
|
||||
dice = re.split('(\d+d\d+)', dice)[-1]
|
||||
ops = VALID_OPERATORS_2.split(dice)
|
||||
ops = [a for a in ops if a is not None]
|
||||
|
||||
# dice repair/modification
|
||||
if numDice > 300 or diceVal < 1:
|
||||
raise errors.InvalidArgument('Too many dice rolled.')
|
||||
|
||||
result.max_value = diceVal
|
||||
result.num_dice = numDice
|
||||
result.operators = ops
|
||||
|
||||
for _ in range(numDice):
|
||||
try:
|
||||
tempdice = SingleDice()
|
||||
tempdice.value = random.randint(1, diceVal)
|
||||
tempdice.rolls = [tempdice.value]
|
||||
tempdice.max_value = diceVal
|
||||
tempdice.kept = True
|
||||
result.rolled.append(tempdice)
|
||||
except:
|
||||
result.rolled.append(SingleDice())
|
||||
|
||||
if ops is not None:
|
||||
|
||||
rerollList = []
|
||||
reroll_once = []
|
||||
keep = None
|
||||
to_explode = []
|
||||
to_reroll_add = []
|
||||
|
||||
valid_operators = VALID_OPERATORS_ARRAY
|
||||
last_operator = None
|
||||
for index, op in enumerate(ops):
|
||||
if last_operator is not None and op in valid_operators and not op == last_operator:
|
||||
result.reroll(reroll_once, 1)
|
||||
reroll_once = []
|
||||
result.reroll(rerollList, greedy=True)
|
||||
rerollList = []
|
||||
result.keep(keep)
|
||||
keep = None
|
||||
result.reroll(to_reroll_add, 1, keep_rerolled=True, unique=True)
|
||||
to_reroll_add = []
|
||||
result.reroll(to_explode, greedy=True, keep_rerolled=True)
|
||||
to_explode = []
|
||||
if op == 'rr':
|
||||
rerollList += parse_selectors([list_get(index + 1, 0, ops)], result, greedy=True)
|
||||
if op == 'k':
|
||||
keep = [] if keep is None else keep
|
||||
keep += parse_selectors([list_get(index + 1, 0, ops)], result)
|
||||
if op == 'p':
|
||||
keep = [] if keep is None else keep
|
||||
keep += parse_selectors([list_get(index + 1, 0, ops)], result, inverse=True)
|
||||
if op == 'ro':
|
||||
reroll_once += parse_selectors([list_get(index + 1, 0, ops)], result)
|
||||
if op == 'mi':
|
||||
_min = list_get(index + 1, 0, ops)
|
||||
for r in result.rolled:
|
||||
if r.value < int(_min):
|
||||
r.update(int(_min))
|
||||
if op == 'ma':
|
||||
_max = list_get(index + 1, 0, ops)
|
||||
for r in result.rolled:
|
||||
if r.value > int(_max):
|
||||
r.update(int(_max))
|
||||
if op == 'ra':
|
||||
to_reroll_add += parse_selectors([list_get(index + 1, 0, ops)], result)
|
||||
if op == 'e':
|
||||
to_explode += parse_selectors([list_get(index + 1, 0, ops)], result, greedy=True)
|
||||
if op in valid_operators:
|
||||
last_operator = op
|
||||
result.reroll(reroll_once, 1)
|
||||
result.reroll(rerollList, greedy=True)
|
||||
result.keep(keep)
|
||||
result.reroll(to_reroll_add, 1, keep_rerolled=True, unique=True)
|
||||
result.reroll(to_explode, greedy=True, keep_rerolled=True)
|
||||
|
||||
return result
|
||||
|
||||
|
||||
class Part:
|
||||
"""Class to hold one part of the roll string."""
|
||||
pass
|
||||
|
||||
|
||||
class SingleDiceGroup(Part):
|
||||
def __init__(self, num_dice: int = 0, max_value: int = 0, rolled=None, annotation: str = "", result: str = "",
|
||||
operators=None):
|
||||
if operators is None:
|
||||
operators = []
|
||||
if rolled is None:
|
||||
rolled = []
|
||||
self.num_dice = num_dice
|
||||
self.max_value = max_value
|
||||
self.rolled = rolled # list of SingleDice
|
||||
self.annotation = annotation
|
||||
self.result = result
|
||||
self.operators = operators
|
||||
|
||||
def keep(self, rolls_to_keep):
|
||||
if rolls_to_keep is None: return
|
||||
for _roll in self.rolled:
|
||||
if not _roll.value in rolls_to_keep:
|
||||
_roll.kept = False
|
||||
elif _roll.kept:
|
||||
rolls_to_keep.remove(_roll.value)
|
||||
|
||||
def reroll(self, rerollList, max_iterations=1000, greedy=False, keep_rerolled=False, unique=False):
|
||||
if not rerollList: return # don't reroll nothing - minor optimization
|
||||
if unique:
|
||||
rerollList = list(set(rerollList)) # remove duplicates
|
||||
if len(rerollList) > 100:
|
||||
raise OverflowError("Too many dice to reroll (max 100)")
|
||||
last_index = 0
|
||||
count = 0
|
||||
should_continue = True
|
||||
while should_continue: # let's only iterate 250 times for sanity
|
||||
should_continue = False
|
||||
if any(d.value in set(rerollList) for d in self.rolled[last_index:] if d.kept and not d.exploded):
|
||||
should_continue = True
|
||||
to_extend = []
|
||||
for r in self.rolled[last_index:]: # no need to recheck everything
|
||||
count += 1
|
||||
if count > max_iterations:
|
||||
should_continue = False
|
||||
if r.value in rerollList and r.kept and not r.exploded:
|
||||
try:
|
||||
tempdice = SingleDice()
|
||||
tempdice.value = random.randint(1, self.max_value)
|
||||
tempdice.rolls = [tempdice.value]
|
||||
tempdice.max_value = self.max_value
|
||||
tempdice.kept = True
|
||||
to_extend.append(tempdice)
|
||||
if not keep_rerolled:
|
||||
r.drop()
|
||||
else:
|
||||
r.explode()
|
||||
except:
|
||||
to_extend.append(SingleDice())
|
||||
if not keep_rerolled:
|
||||
r.drop()
|
||||
else:
|
||||
r.explode()
|
||||
if not greedy:
|
||||
rerollList.remove(r.value)
|
||||
last_index = len(self.rolled)
|
||||
self.rolled.extend(to_extend)
|
||||
|
||||
def get_total(self):
|
||||
"""Returns:
|
||||
int - The total value of the dice."""
|
||||
return sum(r.value for r in self.rolled if r.kept)
|
||||
|
||||
def get_eval(self):
|
||||
return str(self.get_total())
|
||||
|
||||
def get_num_kept(self):
|
||||
return sum(1 for r in self.rolled if r.kept)
|
||||
|
||||
def get_crit(self):
|
||||
"""Returns:
|
||||
int - 0 for no crit, 1 for crit, 2 for crit fail."""
|
||||
if self.get_num_kept() == 1 and self.max_value == 20:
|
||||
if self.get_total() == 20:
|
||||
return 1
|
||||
elif self.get_total() == 1:
|
||||
return 2
|
||||
return 0
|
||||
|
||||
def __str__(self):
|
||||
return "{0.num_dice}d{0.max_value}{1} ({2}) {0.annotation}".format(
|
||||
self, ''.join(self.operators), ', '.join(str(r) for r in self.rolled))
|
||||
|
||||
def to_dict(self):
|
||||
return {'type': 'dice', 'dice': [d.to_dict() for d in self.rolled], 'annotation': self.annotation,
|
||||
'value': self.get_total(), 'is_crit': self.get_crit(), 'num_kept': self.get_num_kept(),
|
||||
'text': str(self), 'num_dice': self.num_dice, 'dice_size': self.max_value, 'operators': self.operators}
|
||||
|
||||
|
||||
class SingleDice:
|
||||
def __init__(self, value: int = 0, max_value: int = 0, kept: bool = True, exploded: bool = False):
|
||||
self.value = value
|
||||
self.max_value = max_value
|
||||
self.kept = kept
|
||||
self.rolls = [value] # list of ints (for X -> Y -> Z)
|
||||
self.exploded = exploded
|
||||
|
||||
def drop(self):
|
||||
self.kept = False
|
||||
|
||||
def explode(self):
|
||||
self.exploded = True
|
||||
|
||||
def update(self, new_value):
|
||||
self.value = new_value
|
||||
self.rolls.append(new_value)
|
||||
|
||||
def __str__(self):
|
||||
formatted_rolls = [str(r) for r in self.rolls]
|
||||
if int(formatted_rolls[-1]) == self.max_value or int(formatted_rolls[-1]) == 1:
|
||||
formatted_rolls[-1] = '**' + formatted_rolls[-1] + '**'
|
||||
if self.exploded:
|
||||
formatted_rolls[-1] = '__' + formatted_rolls[-1] + '__'
|
||||
if self.kept:
|
||||
return ' -> '.join(formatted_rolls)
|
||||
else:
|
||||
return '~~' + ' -> '.join(formatted_rolls) + '~~'
|
||||
|
||||
def __repr__(self):
|
||||
return "<SingleDice object: value={0.value}, max_value={0.max_value}, kept={0.kept}, rolls={0.rolls}>".format(
|
||||
self)
|
||||
|
||||
def to_dict(self):
|
||||
return {'type': 'single_dice', 'value': self.value, 'size': self.max_value, 'is_kept': self.kept,
|
||||
'rolls': self.rolls, 'exploded': self.exploded}
|
||||
|
||||
|
||||
class Constant(Part):
|
||||
def __init__(self, value: int = 0, annotation: str = ""):
|
||||
self.value = value
|
||||
self.annotation = annotation if annotation is not None else ''
|
||||
|
||||
def __str__(self):
|
||||
return "{0.value} {0.annotation}".format(self)
|
||||
|
||||
def get_eval(self):
|
||||
return str(self.value)
|
||||
|
||||
def to_dict(self):
|
||||
return {'type': 'constant', 'value': self.value, 'annotation': self.annotation}
|
||||
|
||||
|
||||
class Operator(Part):
|
||||
def __init__(self, op: str = "+", annotation: str = ""):
|
||||
self.op = op if op is not None else ''
|
||||
self.annotation = annotation if annotation is not None else ''
|
||||
|
||||
def __str__(self):
|
||||
return "{0.op} {0.annotation}".format(self)
|
||||
|
||||
def get_eval(self):
|
||||
return self.op
|
||||
|
||||
def to_dict(self):
|
||||
return {'type': 'operator', 'value': self.op, 'annotation': self.annotation}
|
||||
|
||||
|
||||
class Comment(Part):
|
||||
def __init__(self, comment: str = ""):
|
||||
self.comment = comment
|
||||
|
||||
def __str__(self):
|
||||
return self.comment.strip()
|
||||
|
||||
def to_dict(self):
|
||||
return {'type': 'comment', 'value': self.comment}
|
||||
|
||||
|
||||
def parse_selectors(opts, res, greedy=False, inverse=False):
|
||||
"""Returns a list of ints."""
|
||||
for o in range(len(opts)):
|
||||
if opts[o][0] is 'h':
|
||||
opts[o] = nlargest(int(opts[o].split('h')[1]), (d.value for d in res.rolled if d.kept))
|
||||
elif opts[o][0] is 'l':
|
||||
opts[o] = nsmallest(int(opts[o].split('l')[1]), (d.value for d in res.rolled if d.kept))
|
||||
elif opts[o][0] is '>':
|
||||
if greedy:
|
||||
opts[o] = list(range(int(opts[o].split('>')[1]) + 1, res.max_value + 1))
|
||||
else:
|
||||
opts[o] = [d.value for d in res.rolled if d.value > int(opts[o].split('>')[1])]
|
||||
elif opts[o][0] is '<':
|
||||
if greedy:
|
||||
opts[o] = list(range(1, int(opts[o].split('<')[1])))
|
||||
else:
|
||||
opts[o] = [d.value for d in res.rolled if d.value < int(opts[o].split('<')[1])]
|
||||
out = []
|
||||
for o in opts:
|
||||
if isinstance(o, list):
|
||||
out.extend(int(l) for l in o)
|
||||
elif not greedy:
|
||||
out.extend(int(o) for a in res.rolled if a.value is int(o) and a.kept)
|
||||
else:
|
||||
out.append(int(o))
|
||||
|
||||
if not inverse:
|
||||
return out
|
||||
|
||||
inverse_out = []
|
||||
for rolled in res.rolled:
|
||||
if rolled.kept and rolled.value in out:
|
||||
out.remove(rolled.value)
|
||||
elif rolled.kept:
|
||||
inverse_out.append(rolled.value)
|
||||
return inverse_out
|
||||
|
||||
|
||||
class DiceResult:
|
||||
"""Class to hold the output of a dice roll."""
|
||||
|
||||
def __init__(self, result: int = 0, verbose_result: str = '', crit: int = 0, rolled: str = '', skeleton: str = '',
|
||||
raw_dice: Roll = None):
|
||||
self.plain = result
|
||||
self.total = result
|
||||
self.result = verbose_result
|
||||
self.crit = crit
|
||||
self.rolled = rolled
|
||||
self.skeleton = skeleton if skeleton is not '' else verbose_result
|
||||
self.raw_dice = raw_dice # Roll
|
||||
|
||||
def __str__(self):
|
||||
return self.result
|
||||
|
||||
def __repr__(self):
|
||||
return '<DiceResult object: total={}>'.format(self.total)
|
||||
|
||||
def consolidated(self):
|
||||
"""Gets the most simplified version of the roll string."""
|
||||
if self.raw_dice is None:
|
||||
return "0"
|
||||
parts = [] # list of (part, annotation)
|
||||
last_part = ""
|
||||
for p in self.raw_dice.parts:
|
||||
if isinstance(p, SingleDiceGroup):
|
||||
last_part += str(p.get_total())
|
||||
else:
|
||||
last_part += str(p)
|
||||
if not isinstance(p, Comment) and p.annotation:
|
||||
parts.append((last_part, p.annotation))
|
||||
last_part = ""
|
||||
if last_part:
|
||||
parts.append((last_part, ""))
|
||||
|
||||
to_roll = ""
|
||||
last_annotation = ""
|
||||
out = ""
|
||||
for numbers, annotation in parts:
|
||||
if annotation and annotation != last_annotation and to_roll:
|
||||
out += f"{roll(to_roll).total:+} {last_annotation}"
|
||||
to_roll = ""
|
||||
if annotation:
|
||||
last_annotation = annotation
|
||||
to_roll += numbers
|
||||
if to_roll:
|
||||
out += f"{roll(to_roll).total:+} {last_annotation}"
|
||||
out = out.strip('+ ')
|
||||
return out
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
while True:
|
||||
print(roll(input().strip()))
|
||||
Reference in New Issue
Block a user