tenebrous-dicebot/src/roll.rs

247 lines
7.2 KiB
Rust
Raw Normal View History

2020-04-20 17:19:50 +00:00
use rand::prelude::*;
2020-04-20 19:44:18 +00:00
use std::ops::{Deref, DerefMut};
2020-04-20 17:19:50 +00:00
use crate::dice;
2020-04-20 19:44:18 +00:00
use std::fmt;
use std::string::ToString;
2020-04-20 17:19:50 +00:00
pub trait Roll {
type Output;
fn roll(&self) -> Self::Output;
}
2020-04-20 19:44:18 +00:00
pub trait Rolled {
fn rolled_value(&self) -> i32;
}
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct DiceRoll(Vec<u32>);
impl DiceRoll {
pub fn rolls(&self) -> &[u32] {
&self.0
}
pub fn total(&self) -> u32 {
self.0.iter().sum()
}
}
impl Rolled for DiceRoll {
fn rolled_value(&self) -> i32 {
self.total() as i32
}
}
impl fmt::Display for DiceRoll {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.rolled_value())?;
let rolls = self.rolls();
let mut iter = rolls.iter();
if let Some(first) = iter.next() {
write!(f, " ({}", first)?;
for roll in iter {
write!(f, " + {}", roll)?;
}
write!(f, ")")?;
}
Ok(())
}
}
2020-04-20 17:19:50 +00:00
impl Roll for dice::Dice {
2020-04-20 19:44:18 +00:00
type Output = DiceRoll;
2020-04-20 17:19:50 +00:00
2020-04-20 19:44:18 +00:00
fn roll(&self) -> DiceRoll {
2020-04-20 17:19:50 +00:00
let mut rng = rand::thread_rng();
2020-04-20 19:44:18 +00:00
let rolls = (0..self.count).map(|_| rng.gen_range(1, self.sides + 1)).collect();
DiceRoll(rolls)
}
}
#[derive(Debug, PartialEq, Eq, Clone)]
pub enum ElementRoll {
Dice(DiceRoll),
Bonus(u32),
}
impl Rolled for ElementRoll {
fn rolled_value(&self) -> i32 {
match self {
ElementRoll::Dice(d) => d.rolled_value(),
ElementRoll::Bonus(b) => *b as i32,
}
2020-04-20 17:19:50 +00:00
}
}
impl Roll for dice::Element {
2020-04-20 19:44:18 +00:00
type Output = ElementRoll;
fn roll(&self) -> ElementRoll {
match self {
dice::Element::Dice(d) => ElementRoll::Dice(d.roll()),
dice::Element::Bonus(b) => ElementRoll::Bonus(*b),
}
}
}
impl fmt::Display for ElementRoll {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
ElementRoll::Dice(d) => write!(f, "{}", d),
ElementRoll::Bonus(b) => write!(f, "{}", b),
}
}
}
#[derive(Debug, PartialEq, Eq, Clone)]
pub enum SignedElementRoll {
Positive(ElementRoll),
Negative(ElementRoll),
}
2020-04-20 17:19:50 +00:00
2020-04-20 19:44:18 +00:00
impl Rolled for SignedElementRoll {
fn rolled_value(&self) -> i32 {
2020-04-20 17:19:50 +00:00
match self {
2020-04-20 19:44:18 +00:00
SignedElementRoll::Positive(e) => e.rolled_value(),
SignedElementRoll::Negative(e) => -e.rolled_value(),
2020-04-20 17:19:50 +00:00
}
}
}
impl Roll for dice::SignedElement {
2020-04-20 19:44:18 +00:00
type Output = SignedElementRoll;
2020-04-20 17:19:50 +00:00
2020-04-20 19:44:18 +00:00
fn roll(&self) -> SignedElementRoll {
2020-04-20 17:19:50 +00:00
match self {
2020-04-20 19:44:18 +00:00
dice::SignedElement::Positive(e) => SignedElementRoll::Positive(e.roll()),
dice::SignedElement::Negative(e) => SignedElementRoll::Negative(e.roll()),
2020-04-20 17:19:50 +00:00
}
}
}
2020-04-20 19:44:18 +00:00
impl fmt::Display for SignedElementRoll {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
SignedElementRoll::Positive(e) => write!(f, "{}", e),
SignedElementRoll::Negative(e) => write!(f, "-{}", e),
}
}
}
#[derive(Debug, PartialEq, Eq, Clone)]
pub struct ElementExpressionRoll(Vec<SignedElementRoll>);
impl Deref for ElementExpressionRoll {
type Target = Vec<SignedElementRoll>;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl DerefMut for ElementExpressionRoll {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl Rolled for ElementExpressionRoll {
fn rolled_value(&self) -> i32 {
self.iter().map(Rolled::rolled_value).sum()
}
}
impl Roll for dice::ElementExpression {
type Output = ElementExpressionRoll;
fn roll(&self) -> ElementExpressionRoll {
ElementExpressionRoll(self.iter().map(Roll::roll).collect())
}
}
impl fmt::Display for ElementExpressionRoll {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
if self.len() > 1 {
write!(f, "{}", self.rolled_value())?;
let mut iter = self.0.iter();
if let Some(first) = iter.next() {
write!(f, " ({}", first)?;
for roll in iter {
match roll {
SignedElementRoll::Positive(e) => write!(f, " + {}", e)?,
SignedElementRoll::Negative(e) => write!(f, " - {}", e)?,
}
}
write!(f, ")")?;
}
Ok(())
} else if self.len() > 0 {
// For a single item, just show the inner item to avoid redundancy
let first = self.0.iter().next().unwrap();
write!(f, "{}", first)
} else {
write!(f, "0")
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn dice_roll_display_test() {
assert_eq!(DiceRoll(vec![1, 3, 4]).to_string(), "8 (1 + 3 + 4)");
assert_eq!(DiceRoll(vec![]).to_string(), "0");
assert_eq!(DiceRoll(vec![4, 7, 2, 10]).to_string(), "23 (4 + 7 + 2 + 10)");
}
#[test]
fn element_roll_display_test() {
assert_eq!(ElementRoll::Dice(DiceRoll(vec![1, 3, 4])).to_string(), "8 (1 + 3 + 4)");
assert_eq!(ElementRoll::Bonus(7).to_string(), "7");
}
#[test]
fn signed_element_roll_display_test() {
assert_eq!(SignedElementRoll::Positive(ElementRoll::Dice(DiceRoll(vec![1, 3, 4]))).to_string(), "8 (1 + 3 + 4)");
assert_eq!(SignedElementRoll::Negative(ElementRoll::Dice(DiceRoll(vec![1, 3, 4]))).to_string(), "-8 (1 + 3 + 4)");
assert_eq!(SignedElementRoll::Positive(ElementRoll::Bonus(7)).to_string(), "7");
assert_eq!(SignedElementRoll::Negative(ElementRoll::Bonus(7)).to_string(), "-7");
}
#[test]
fn element_expression_roll_display_test() {
assert_eq!(
ElementExpressionRoll(vec![
SignedElementRoll::Positive(ElementRoll::Dice(DiceRoll(vec![1, 3, 4]))),
]).to_string(), "8 (1 + 3 + 4)");
assert_eq!(
ElementExpressionRoll(vec![
SignedElementRoll::Negative(ElementRoll::Dice(DiceRoll(vec![1, 3, 4]))),
]).to_string(), "-8 (1 + 3 + 4)");
assert_eq!(
ElementExpressionRoll(vec![
SignedElementRoll::Positive(ElementRoll::Bonus(7)),
]).to_string(), "7");
assert_eq!(
ElementExpressionRoll(vec![
SignedElementRoll::Negative(ElementRoll::Bonus(7)),
]).to_string(), "-7");
assert_eq!(
ElementExpressionRoll(vec![
SignedElementRoll::Positive(ElementRoll::Dice(DiceRoll(vec![1, 3, 4]))),
SignedElementRoll::Negative(ElementRoll::Dice(DiceRoll(vec![1, 2]))),
SignedElementRoll::Positive(ElementRoll::Bonus(4)),
SignedElementRoll::Negative(ElementRoll::Bonus(7)),
]).to_string(), "2 (8 (1 + 3 + 4) - 3 (1 + 2) + 4 - 7)");
assert_eq!(
ElementExpressionRoll(vec![
SignedElementRoll::Negative(ElementRoll::Dice(DiceRoll(vec![1, 3, 4]))),
SignedElementRoll::Positive(ElementRoll::Dice(DiceRoll(vec![1, 2]))),
SignedElementRoll::Negative(ElementRoll::Bonus(4)),
SignedElementRoll::Positive(ElementRoll::Bonus(7)),
]).to_string(), "-2 (-8 (1 + 3 + 4) + 3 (1 + 2) - 4 + 7)");
}
}