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

use rand::Rng;

/// Defines a type that can be rolled for.
/// Implement this trait on a type you would like to roll for.
///
/// # Example
///
/// ```
/// use one_d_six::{
///     Die,
///     Rollable,
///     quickroll,
/// };
///
/// #[derive(Clone, Copy, Debug)]
/// enum Shapes {
///     Triangle,
///     Square,
///     Circle,
/// }
///
/// impl Rollable for Shapes {
///     // We're ignoring max since we don't need a maximum for this example
///     fn roll(_max: Shapes) -> Shapes {
///         let roll_result: u8 = quickroll("1d3");
///         match roll_result {
///             1 => Shapes::Triangle,
///             2 => Shapes::Square,
///             3 => Shapes::Circle,
///             _ => unreachable!(),
///         }
///     }
/// }
///
/// // We still need a maximum to satisfy Rollable::roll requirements
/// let max = Shapes::Circle;
/// let mut shape_roller = Die::new(max);
/// println!("You rolled {:?}!", shape_roller.roll());
/// ```
pub trait Rollable: Copy {
    fn roll(max: Self) -> Self;
}

impl Rollable for u8 {
    fn roll(max: u8) -> u8 {
        rand::thread_rng().gen_range(0, max) + 1
    }
}
impl Rollable for u16 {
    fn roll(max: u16) -> u16 {
        rand::thread_rng().gen_range(0, max) + 1
    }
}
impl Rollable for u32 {
    fn roll(max: u32) -> u32 {
        rand::thread_rng().gen_range(0, max) + 1
    }
}
impl Rollable for u64 {
    fn roll(max: u64) -> u64 {
        rand::thread_rng().gen_range(0, max) + 1
    }
}
impl Rollable for u128 {
    fn roll(max: u128) -> u128 {
        rand::thread_rng().gen_range(0, max) + 1
    }
}
impl Rollable for usize {
    fn roll(max: usize) -> usize {
        rand::thread_rng().gen_range(0, max) + 1
    }
}
impl Rollable for i8 {
    fn roll(max: i8) -> i8 {
        rand::thread_rng().gen_range(0, max) + 1
    }
}
impl Rollable for i16 {
    fn roll(max: i16) -> i16 {
        rand::thread_rng().gen_range(0, max) + 1
    }
}
impl Rollable for i32 {
    fn roll(max: i32) -> i32 {
        rand::thread_rng().gen_range(0, max) + 1
    }
}
impl Rollable for i64 {
    fn roll(max: i64) -> i64 {
        rand::thread_rng().gen_range(0, max) + 1
    }
}
impl Rollable for i128 {
    fn roll(max: i128) -> i128 {
        rand::thread_rng().gen_range(0, max) + 1
    }
}
impl Rollable for isize {
    fn roll(max: isize) -> isize {
        rand::thread_rng().gen_range(0, max) + 1
    }
}