def test_compile_int(self):
expected = EvalTree(None)
expected.root = EvalTreeNode(2)
self.assertEqual(compile(2), expected)
expected.root = EvalTreeNode(OPERATORS['+'], EvalTreeNode(2),
EvalTreeNode(4))
self.assertEqual(compile(2, 4), expected)
def ability_save(self, which: 'abil.AbilityName', adv=False, dis=False):
roll = h.d20_roll(adv, dis, self.bonuses.get('lucky', False))
roll += d.compile(self.abilities[which].modifier)
if which in self.saves:
roll += d.compile(self.proficiency)
abilityBonus = self.bonuses.get('save_' + which.value)
if abilityBonus:
roll += d.compile(self.parse_vars(abilityBonus))
return roll.evaluate(), roll
def do_attack(self, lucky=False):
attack = self.adv.d20_roll(lucky)
attack += d.compile(self.attack.get())
attack.evaluate()
damage = d.compile(self.damage.get())
if attack.is_critical():
damage.critify()
self.attackResult.set(attack, 'Attack roll: {}')
self.damageResult.set(damage, 'Damage roll: {}')
def main():
args = parse()
mode = Mode.NORMAL
if args.maximum:
mode = Mode.MAX
elif args.critical:
mode = Mode.CRIT
elif args.average:
mode = Mode.AVERAGE
func = basic
if args.verbose:
func = verbose
wrap = args.wrap
for expr in args.expression:
length = 0
compiled = compile(expr)
for each in range(args.number):
val = func(compiled, mode)
s = "{} ".format(val)
if wrap > 0:
length += len(s)
if length > wrap:
# print a newline before to prevent from
# overstepping the line length restriction
print()
length = len(s)
print(s, end="")
print()
def test_compile_modifier(self):
expected = EvalTree(None)
expected.root = EvalTreeNode(
OPERATORS['+'],
EvalTreeNode(OPERATORS['d'], EvalTreeNode(3), EvalTreeNode(4)),
EvalTreeNode(2))
self.assertEqual(compile('3d4', 2), expected)
def __getitem__(self, expression: str) -> EvalTree:
if expression not in self.cache:
try:
self.cache[expression] = compile(expression)
except ParseError:
raise
return self.cache[expression]
pass
pass
def do_attack(self):
adv = self.advantage.get()
dis = self.disadvantage.get()
attack = h.d20_roll(adv, dis)
attack += d.compile(self.attack.get())
attroll = d.verbose(attack)
###
if attack.is_critical():
attroll = 'Critical Hit'
damresult = d.verbose(self.damage.get(), d.Mode.CRIT)
elif attack.is_fail():
attroll = 'Critical Miss'
damresult = '0'
else:
damresult = d.verbose(self.damage.get())
###
self.attackResult['text'] = 'Attack result: ' + attroll
self.damageResult['text'] = 'Damage done: ' + damresult
def attack(self, which):
advantage = self.adv.get()
disadvantage = self.dis.get()
attack_bonus = self.character.parse_vars(self.atkbonus.get(), False)
damage_bonus = self.character.parse_vars(self.dambonus.get(), False)
if which is None:
attack = h.d20_roll(advantage, disadvantage, self.character.bonuses.get('lucky', False))
attack += d.compile(attack_bonus)
attackRoll = attack.evaluate()
if attack.is_critical():
attackRoll = 'Critical Hit!'
damageRoll = d.basic(damage_bonus, mode=d.Mode.CRIT)
elif attack.is_fail():
attackRoll = 'Critical Miss.'
damageRoll = 0
else:
# mode = 'execute'
attackRoll = attack.verbose_result()
damageRoll = d.basic(damage_bonus)
result = ('Attack Roll: ' + str(attackRoll), 'Damage Roll: ' + str(damageRoll), '')
# result = ('Attack Roll: ' + str(atk), 'Damage Roll: ' + str(dam), '')
else:
result = which.attack(self.character, advantage, disadvantage, attack_bonus, damage_bonus)
self.output.update(*result)
def ability_check(self,
which: 'abil.AbilityName',
skill='',
adv=False,
dis=False):
roll = h.d20_roll(adv, dis, self.bonuses.get('lucky', False))
roll += d.compile(self.abilities[which].modifier)
if skill == '':
# plain ability check
abilityBonus = self.bonuses.get('check_' + which.value)
if abilityBonus:
roll += d.compile(self.parse_vars(abilityBonus))
if self.bonuses.get('jack_of_all_trades', False):
roll += d.compile(self.proficiency // 2)
else:
if skill in self.skills:
roll += d.compile(self.proficiency)
elif self.bonuses.get('jack_of_all_trades', False):
roll += d.compile(self.proficiency // 2)
skillBonus = self.bonuses.get('skill_' + skill)
if skillBonus:
roll += d.compile(self.parse_vars(skillBonus))
return roll.evaluate(), roll
def do_roll(self):
self.result.set(d.compile(self.generalRoll.get()))
def roll(self, extra: Optional[d.core.EvalTree] = None):
expr = self.advantage.d20_roll()
expr += d.compile(self.ability.modifier)
if extra:
expr += extra
self.display.set(expr)
def change_hp(self):
tree = d.compile(self.entry.get())
value = tree.evaluate()
self.handler.change(value)
self.amount.set(tree)
self.onChange()
def test_compile_wrong_type(self):
with self.assertRaises(InputTypeError):
compile([40, 2])
def do_roll(self):
s = self.generalRoll.get()
parsed = self.character.parse_vars(s, mathIt=False)
self.result.set(d.compile(parsed))
def add_temp(self):
tree = d.compile(self.entry.get())
value = tree.evaluate()
self.handler.add_temp(value)
self.amount.set(tree)
self.onTemp()
import functools
import json
import os
import re
import typing
from operator import lt, gt
import dndice as r
D20 = r.compile('1d20')
D20_LUCK = r.compile('1d20r1')
ADV = r.compile('2d20h1')
ADV_LUCK = r.compile('2d20r1h1')
DIS = r.compile('2d20l1')
DIS_LUCK = r.compile('2d20r1l1')
def modifier(score):
return (int(score) - 10) // 2
def d20_roll(adv=False, dis=False, luck=False):
"""Return the d20 roll to make under the given conditions."""
if adv and not dis:
if luck:
return ADV_LUCK.copy()
else:
return ADV.copy()
elif dis and not adv:
if luck:
return DIS_LUCK.copy()
def test_compile(self):
tree = compile('3d4')
expected = EvalTree(None)
expected.root = EvalTreeNode(OPERATORS['d'], EvalTreeNode(3),
EvalTreeNode(4))
self.assertEqual(tree, expected)
