Enum critfail::Roll

pub enum Roll {
    Check(Check),
    Damage(Damage),
    Attack(Attack),
}

Any kind of roll—either a check, damage, or attack roll.

This struct is useful when parsing a roll expression if you don't know what type of roll expression it will be.

use critfail::{RollExpression, Roll};

let check = Roll::new("r-3").unwrap();
let check_outcome = check.roll();
print!("{}", check_outcome); // eg. "11"
print!("{:?}", check_outcome); // eg. "(14)-3"

let damage = Roll::new("2d8+6").unwrap();
let damage_outcome = damage.roll();
print!("{}", damage_outcome); // eg. "13"
print!("{:?}", damage_outcome); // eg. "[2+5]+6"

let attack = Roll::new("r+1?2d6+4").unwrap();
let attack_outcome = attack.roll();
print!("{}", attack_outcome); // eg. "10 ? 16"
print!("{:?}", attack_outcome); // eg. "(9)+1 ? [6+6]+4"

Variants

Check(Check)

A Roll containing a Check roll.

Damage(Damage)

A Roll containing a Damage roll.

Attack(Attack)

A Roll containing an Attack roll.

Implementations

impl Roll

pub fn is_check(&self) -> bool

Return true if this Roll is a check roll.

use critfail::{RollExpression, Roll};

assert_eq!(Roll::new("r+3").unwrap().is_check(), true);
assert_eq!(Roll::new("2d8+5").unwrap().is_check(), false);
assert_eq!(Roll::new("r+3?2d8+5").unwrap().is_check(), false);

pub fn is_damage(&self) -> bool

Return true if this Roll is a damage roll.

use critfail::{RollExpression, Roll};

assert_eq!(Roll::new("r+3").unwrap().is_damage(), false);
assert_eq!(Roll::new("2d8+5").unwrap().is_damage(), true);
assert_eq!(Roll::new("r+3?2d8+5").unwrap().is_damage(), false);

pub fn is_attack(&self) -> bool

Return true if this Roll is an attack roll.

use critfail::{RollExpression, Roll};

assert_eq!(Roll::new("r+3").unwrap().is_attack(), false);
assert_eq!(Roll::new("2d8+5").unwrap().is_attack(), false);
assert_eq!(Roll::new("r+3?2d8+5").unwrap().is_attack(), true);

Trait Implementations

impl Clone for Roll

fn clone(&self) -> Roll

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Roll

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl From<Attack> for Roll

fn from(attack: Attack) -> Self

Performs the conversion.

impl From<Check> for Roll

fn from(check: Check) -> Self

Performs the conversion.

impl From<Damage> for Roll

fn from(damage: Damage) -> Self

Performs the conversion.

impl FromStr for Roll

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl PartialEq<Roll> for Roll

fn eq(&self, other: &Roll) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Roll) -> bool

This method tests for !=.

impl RollExpression for Roll

type Outcome = RollOutcome

The roll result type should implement both Display and Debug. Display should print out a consise result for the roll, and Debug should print out the details (eg the value for each rolled die).

fn roll(&self) -> Self::Outcome

Roll the dice and return an outcome.

fn new(expression: &str) -> Result<Self, ParseError>

Create a new roll expression by parsing the given string.

impl StructuralPartialEq for Roll