Enum critfail::RollOutcome

pub enum RollOutcome {
    Check(CheckOutcome),
    Damage(DamageOutcome),
    Attack(AttackOutcome),
}

The outcome of rolling a check, damage, or attack roll.

This is normally constructed as the result of calling roll() on a Roll roll expression.

A RollOutcome can be printed with Display and Debug, but if you need more information about the result you will need to destructure the enum and handle the different types individually.

use critfail::{RollExpression, Roll, RollOutcome};

let check: RollOutcome = Roll::new("r+6").unwrap().roll();
let damage: RollOutcome = Roll::new("4d4+6").unwrap().roll();
let attack: RollOutcome = Roll::new("r+3?2d8+3").unwrap().roll();

fn print_score(outcome: RollOutcome) {
    match outcome {
        RollOutcome::Check(check) => println!("Check score: {}", check.score()),
        RollOutcome::Damage(damage) => println!("Damage score: {}", damage.score()),
        RollOutcome::Attack(attack) => {
            println!("Check score: {}", attack.check().score());
            println!("Damage score: {}", attack.damage().score())
        }
    }
}

print_score(check);
print_score(damage);
print_score(attack);

Variants

Check(CheckOutcome)

The outcome of a Roll that contained a Check.

Damage(DamageOutcome)

The outcome of a Roll that contained a Damage.

Attack(AttackOutcome)

The outcome of a Roll that contained an Attack.

Implementations

impl RollOutcome

pub fn is_check(&self) -> bool

Return true if this RollOutcome is the outcome of a check roll.

use critfail::{RollExpression, Roll};

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

pub fn is_damage(&self) -> bool

Return true if this RollOutcome is the outcome of a damage roll.

use critfail::{RollExpression, Roll};

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

pub fn is_attack(&self) -> bool

Return true if this RollOutcome is the outcome of an attack roll.

use critfail::{RollExpression, Roll};

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

Trait Implementations

impl Clone for RollOutcome

fn clone(&self) -> RollOutcome

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RollOutcome

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

Formats the value using the given formatter.

impl Display for RollOutcome

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

Formats the value using the given formatter.

impl From<AttackOutcome> for RollOutcome

fn from(o: AttackOutcome) -> Self

Performs the conversion.

impl From<CheckOutcome> for RollOutcome

fn from(o: CheckOutcome) -> Self

Performs the conversion.

impl From<DamageOutcome> for RollOutcome

fn from(o: DamageOutcome) -> Self

Performs the conversion.