noctisroll 0.2.1

A modern, modular TRPG dice rolling system implementing the OneDice standard
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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

use noctisroll::prelude::*;

#[test]
fn test_standard_dice() {
    // Test basic dice
    let dice = StandardDice::new(2, 6);
    let result = dice.roll();

    assert!(result.total >= 2 && result.total <= 12);
    assert_eq!(result.rolls.len(), 2);

    // Test with keep highest
    let dice = StandardDice::new(4, 6).keep_highest(2);
    let result = dice.roll();

    assert!(result.total >= 2 && result.total <= 12);
    assert_eq!(result.rolls.len(), 2); // Only kept rolls

    // Test with keep lowest
    let dice = StandardDice::new(4, 6).keep_lowest(2);
    let result = dice.roll();

    assert!(result.total >= 2 && result.total <= 12);
    assert_eq!(result.rolls.len(), 2);
}

#[test]
fn test_fate_dice() {
    let dice = FateDice::new(4);
    let result = dice.roll();

    // 4dF ranges from -4 to +4
    assert!(result.total >= -4 && result.total <= 4);
    assert_eq!(result.rolls.len(), 4);
}

#[test]
fn test_exploding_dice() {
    let dice = ExplodingDice::new(2, 6, 6); // Explode on 6
    let result = dice.roll();

    // At least 2 dice rolled
    assert!(result.rolls.len() >= 2);

    // All rolls should be between 1 and 6
    for roll in &result.rolls {
        assert!(roll.value >= 1 && roll.value <= 6);
    }
}

#[test]
fn test_dice_validation() {
    // Invalid dice should fail validation
    let dice = StandardDice::new(2, 0);
    assert!(dice.validate().is_err());

    // Valid dice should pass
    let dice = StandardDice::new(2, 6);
    assert!(dice.validate().is_ok());

    // Dice with 0 count is actually valid (empty roll)
    let dice = StandardDice::new(0, 6);
    assert!(dice.validate().is_ok());
}

#[test]
fn test_roll_statistics() {
    use noctisroll::utils::RollStatistics;

    let dice = StandardDice::new(100, 6);
    let result = dice.roll();
    let stats = RollStatistics::from_result(&result);

    assert!(stats.min >= 1 && stats.min <= 6);
    assert!(stats.max >= 1 && stats.max <= 6);
    assert!(stats.mean >= 1.0 && stats.mean <= 6.0);
}

#[test]
fn test_convenience_functions() {
    // Test d() function
    let dice = d(2, 20);
    let result = dice.roll();
    assert!(result.total >= 2 && result.total <= 40);

    // Test f() function
    let dice = f(4);
    let result = dice.roll();
    assert!(result.total >= -4 && result.total <= 4);

    // Test x() function
    let dice = x(2, 6, 6);
    let result = dice.roll();
    assert!(result.rolls.len() >= 2);
}

#[test]
fn test_dice_pool() {
    // Test infinite adding pool
    let pool = InfiniteAddingPool::new(5, 8); // 5 dice, add on 8+
    let result = pool.roll();

    assert!(result.total >= 0);
    // success_count is always >= 0 by definition, no need to assert

    // Test double cross pool
    let pool = DoubleCrossPool::new(5, 8); // 5 dice, add on 8+
    let result = pool.roll();

    assert!(result.total >= 1); // At least max of first roll
}

#[test]
fn test_parse_dice_notation() {
    use noctisroll::utils::parse_dice_notation;

    // Test dX notation
    let dice = parse_dice_notation("d20").unwrap();
    let result = dice.roll();
    assert!(result.total >= 1 && result.total <= 20);

    // Test XdY notation
    let dice = parse_dice_notation("2d6").unwrap();
    let result = dice.roll();
    assert!(result.total >= 2 && result.total <= 12);

    // Test FATE dice
    let dice = parse_dice_notation("4dF").unwrap(); // uppercase F
    let result = dice.roll();
    assert!(result.total >= -4 && result.total <= 4);

    // Test invalid notation
    assert!(parse_dice_notation("invalid").is_err());
}