tyche 0.3.1

Dice rolling and dice expression (with a syntax similar to FoundryVTT) parsing library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

use crate::{
	dice::{roller::FastRand as FastRandRoller, Dice},
	expr::{CalcError, Evaled, Expr},
};

#[test]
fn basic_negation() {
	let expr = Expr::Neg(Box::new(Expr::Num(42)));
	let result = expr.eval(&mut FastRandRoller::default()).unwrap().calc();
	assert_eq!(result.unwrap(), -42);
}

#[test]
fn basic_addition() {
	let expr = Expr::Add(Box::new(Expr::Num(42)), Box::new(Expr::Num(69)));
	let result = expr.eval(&mut FastRandRoller::default()).unwrap().calc();
	assert_eq!(result.unwrap(), 111);
}

#[test]
fn basic_subtraction() {
	let expr = Expr::Sub(Box::new(Expr::Num(42)), Box::new(Expr::Num(69)));
	let result = expr.eval(&mut FastRandRoller::default()).unwrap().calc();
	assert_eq!(result.unwrap(), -27);
}

#[test]
fn basic_multiplication() {
	let expr = Expr::Mul(Box::new(Expr::Num(42)), Box::new(Expr::Num(69)));
	let result = expr.eval(&mut FastRandRoller::default()).unwrap().calc();
	assert_eq!(result.unwrap(), 2898);
}

#[test]
fn basic_division_rounded_down() {
	let expr = Expr::DivDown(Box::new(Expr::Num(50)), Box::new(Expr::Num(11)));
	let result = expr.eval(&mut FastRandRoller::default()).unwrap().calc();
	assert_eq!(result.unwrap(), 4);
}

#[test]
fn basic_division_rounded_up() {
	let expr = Expr::DivUp(Box::new(Expr::Num(50)), Box::new(Expr::Num(11)));
	let result = expr.eval(&mut FastRandRoller::default()).unwrap().calc();
	assert_eq!(result.unwrap(), 5);
}

#[test]
fn complex_math() {
	let expr = Expr::Sub(
		Box::new(Expr::Mul(
			Box::new(Expr::Neg(Box::new(Expr::Num(5)))),
			Box::new(Expr::Add(Box::new(Expr::Num(3)), Box::new(Expr::Num(1)))),
		)),
		Box::new(Expr::DivDown(
			Box::new(Expr::Neg(Box::new(Expr::Num(4)))),
			Box::new(Expr::Num(2)),
		)),
	);
	let result = expr.eval(&mut FastRandRoller::default()).unwrap().calc();
	assert_eq!(result.unwrap(), -18);
}

#[test]
fn basic_dice_math() {
	let dice = Dice::new(4, 6);
	let expr = Expr::Add(Box::new(Expr::Dice(dice)), Box::new(Expr::Num(8)));
	let evaled = expr.eval(&mut FastRandRoller::default()).unwrap();

	let dice_total = if let Evaled::Add(boxed, _) = &evaled {
		if let Evaled::Dice(evaled_dice) = boxed.as_ref() {
			i32::from(evaled_dice.total().unwrap())
		} else {
			panic!()
		}
	} else {
		panic!()
	};

	let total = evaled.calc().unwrap();
	assert_eq!(total, dice_total.checked_add(8).unwrap());
}

#[test]
fn calc_overflow() {
	let expr = Expr::Add(Box::new(Expr::Num(i32::MAX)), Box::new(Expr::Num(1)));
	let result = expr.eval(&mut FastRandRoller::default()).unwrap().calc();
	assert!(result.is_err());
	assert!(matches!(result.unwrap_err(), CalcError::Overflow(..)));
}