Struct one_d_six::Die

pub struct Die<T: Rollable = u32> { /* fields omitted */ }

Represents a single die. Has an initial random value.

Examples

Adding roll values

use one_d_six::Die;

let mut d4 = Die::new(4);
let mut d6 = Die::new(6);

let d4_result = d4.roll();
let d6_result = d6.roll();
let result = d4_result + d6_result;

assert!(result >= 2);
assert!(result <= 10);

Adding current values

use one_d_six::Die;

let d4 = Die::new(4);
let d6 = Die::new(6);

let d4_result = d4.current_face();
let d6_result = d6.current_face();
let result = d4_result + d6_result;

assert!(result >= 2);
assert!(result <= 10);

Adding dice directly

use one_d_six::Die;

let d4: Die = Die::new(4);
let d6 = Die::new(6);

let result = d4 + d6;

assert!(result >= 2);
assert!(result <= 10);

Methods

impl<T: Rollable> Die<T>

pub fn new(faces: T) -> Self

Creates a single die with the specified number of faces.

Example

use one_d_six::Die;

let coin = Die::new(2);

pub fn roll(&mut self) -> T

Rolls a single die.

Example

use one_d_six::Die;

let mut d6 = Die::new(6);

assert!(d6.roll() >= 1);
assert!(d6.current_face() <= 6);

pub fn current_face(&self) -> T

Gets the current value of the die.

Example

use one_d_six::Die;

let d4 = Die::new(4);

assert!(d4.current_face() >= 1);
assert!(d4.current_face() <= 4);

Trait Implementations

impl<T: Rollable> Add<Die<T>> for Die<T> where
    T: Add, 

type Output = T::Output

The resulting type after applying the + operator.

fn add(self, other: Self) -> Self::Output

Performs the + operation.