780 lines
24 KiB
Rust
780 lines
24 KiB
Rust
use crate::context::Context;
|
|
use crate::error::{BotError, DiceRollingError};
|
|
use crate::parser::dice::{Amount, Element, Operator};
|
|
use itertools::Itertools;
|
|
use std::convert::TryFrom;
|
|
use std::fmt;
|
|
|
|
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
|
|
pub enum DicePoolQuality {
|
|
TenAgain,
|
|
NineAgain,
|
|
EightAgain,
|
|
Rote,
|
|
ChanceDie,
|
|
NoExplode,
|
|
}
|
|
|
|
impl fmt::Display for DicePoolQuality {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
match self {
|
|
DicePoolQuality::TenAgain => write!(f, "ten-again"),
|
|
DicePoolQuality::NineAgain => write!(f, "nine-again"),
|
|
DicePoolQuality::EightAgain => write!(f, "eight-again"),
|
|
DicePoolQuality::Rote => write!(f, "rote quality"),
|
|
DicePoolQuality::ChanceDie => write!(f, "chance die"),
|
|
DicePoolQuality::NoExplode => write!(f, "no roll-agains"),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
|
|
pub struct DicePoolModifiers {
|
|
pub(crate) success_on: i32,
|
|
pub(crate) exceptional_on: i32,
|
|
pub(crate) quality: DicePoolQuality,
|
|
}
|
|
|
|
impl DicePoolModifiers {
|
|
pub fn default() -> DicePoolModifiers {
|
|
DicePoolModifiers {
|
|
success_on: 8,
|
|
exceptional_on: 5,
|
|
quality: DicePoolQuality::TenAgain,
|
|
}
|
|
}
|
|
|
|
pub fn custom_quality(quality: DicePoolQuality) -> DicePoolModifiers {
|
|
let success_on = if quality != DicePoolQuality::ChanceDie {
|
|
8
|
|
} else {
|
|
10
|
|
};
|
|
DicePoolModifiers {
|
|
success_on: success_on,
|
|
exceptional_on: 5,
|
|
quality: quality,
|
|
}
|
|
}
|
|
|
|
pub fn custom_exceptional_on(exceptional_on: i32) -> DicePoolModifiers {
|
|
DicePoolModifiers {
|
|
success_on: 8,
|
|
exceptional_on: exceptional_on,
|
|
quality: DicePoolQuality::TenAgain,
|
|
}
|
|
}
|
|
|
|
pub fn custom(quality: DicePoolQuality, exceptional_on: i32) -> DicePoolModifiers {
|
|
DicePoolModifiers {
|
|
success_on: 8,
|
|
exceptional_on: exceptional_on,
|
|
quality: quality,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, PartialEq)]
|
|
pub struct DicePool {
|
|
pub(crate) amounts: Vec<Amount>,
|
|
pub(crate) sides: i32,
|
|
pub(crate) modifiers: DicePoolModifiers,
|
|
}
|
|
|
|
impl DicePool {
|
|
pub fn easy_pool(dice_amount: i32, quality: DicePoolQuality) -> DicePool {
|
|
DicePool {
|
|
amounts: vec![Amount {
|
|
operator: Operator::Plus,
|
|
element: Element::Number(dice_amount),
|
|
}],
|
|
sides: 10,
|
|
modifiers: DicePoolModifiers::custom_quality(quality),
|
|
}
|
|
}
|
|
|
|
pub fn easy_with_modifiers(dice_amount: i32, modifiers: DicePoolModifiers) -> DicePool {
|
|
DicePool {
|
|
amounts: vec![Amount {
|
|
operator: Operator::Plus,
|
|
element: Element::Number(dice_amount),
|
|
}],
|
|
sides: 10,
|
|
modifiers: modifiers,
|
|
}
|
|
}
|
|
|
|
pub fn new(amounts: Vec<Amount>, modifiers: DicePoolModifiers) -> DicePool {
|
|
DicePool {
|
|
amounts: amounts,
|
|
sides: 10, //TODO make configurable
|
|
//TODO make configurable
|
|
modifiers: modifiers,
|
|
}
|
|
}
|
|
|
|
pub fn chance_die() -> DicePool {
|
|
DicePool::easy_pool(1, DicePoolQuality::ChanceDie)
|
|
}
|
|
}
|
|
|
|
///The result of a successfully executed roll of a dice pool. Does not
|
|
///contain the heavy information of the DicePool instance.
|
|
pub struct RolledDicePool {
|
|
pub(crate) num_dice: i32,
|
|
pub(crate) roll: DicePoolRoll,
|
|
pub(crate) modifiers: DicePoolModifiers,
|
|
}
|
|
|
|
impl RolledDicePool {
|
|
fn from(pool: &DicePool, num_dice: i32, rolls: Vec<i32>) -> RolledDicePool {
|
|
RolledDicePool {
|
|
modifiers: pool.modifiers,
|
|
num_dice: num_dice,
|
|
roll: DicePoolRoll {
|
|
rolls: rolls,
|
|
modifiers: pool.modifiers,
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
impl fmt::Display for RolledDicePool {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
let dice_plural = if self.num_dice == 1 { "die" } else { "dice" };
|
|
write!(
|
|
f,
|
|
"{} {} ({}, exceptional on {} successes)",
|
|
self.num_dice, dice_plural, self.modifiers.quality, self.modifiers.exceptional_on
|
|
)
|
|
}
|
|
}
|
|
|
|
///Store all rolls of the dice pool dice into one struct.
|
|
#[derive(Debug, PartialEq, Eq, Clone)]
|
|
pub struct DicePoolRoll {
|
|
modifiers: DicePoolModifiers,
|
|
rolls: Vec<i32>,
|
|
}
|
|
|
|
/// Amount of dice to display before cutting off and showing "and X
|
|
/// more", so we don't spam the room with huge messages.
|
|
const MAX_DISPLAYED_ROLLS: usize = 15;
|
|
|
|
fn fmt_rolls(pool: &DicePoolRoll) -> String {
|
|
let rolls = pool.rolls();
|
|
if rolls.len() > MAX_DISPLAYED_ROLLS {
|
|
let shown_amount = rolls.into_iter().take(MAX_DISPLAYED_ROLLS).join(", ");
|
|
format!(
|
|
"{}, and {} more",
|
|
shown_amount,
|
|
rolls.len() - MAX_DISPLAYED_ROLLS
|
|
)
|
|
} else {
|
|
rolls.into_iter().join(", ")
|
|
}
|
|
}
|
|
|
|
fn fmt_for_failure(pool: &DicePoolRoll) -> String {
|
|
match pool.modifiers.quality {
|
|
//There should only be 1 die in a chance die roll.
|
|
DicePoolQuality::ChanceDie if pool.rolls().first() == Some(&1) => {
|
|
String::from("dramatic failure!")
|
|
}
|
|
_ => String::from("failure!"),
|
|
}
|
|
}
|
|
|
|
impl DicePoolRoll {
|
|
pub fn rolls(&self) -> &[i32] {
|
|
&self.rolls
|
|
}
|
|
|
|
pub fn successes(&self) -> i32 {
|
|
let successes: usize = self
|
|
.rolls
|
|
.iter()
|
|
.filter(|&roll| *roll >= self.modifiers.success_on)
|
|
.count();
|
|
|
|
i32::try_from(successes).unwrap_or(0)
|
|
}
|
|
|
|
pub fn is_exceptional(&self) -> bool {
|
|
self.successes() >= self.modifiers.exceptional_on
|
|
}
|
|
}
|
|
|
|
/// Attach a Context to a dice pool. Needed for database access.
|
|
pub struct DicePoolWithContext<'a>(pub &'a DicePool, pub &'a Context<'a>);
|
|
|
|
impl fmt::Display for DicePoolRoll {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
let successes = self.successes();
|
|
if successes > 0 {
|
|
let success_msg = if self.is_exceptional() {
|
|
format!("{} successes (exceptional!)", successes)
|
|
} else {
|
|
format!("{} successes", successes)
|
|
};
|
|
|
|
write!(f, "{} ({})", success_msg, fmt_rolls(&self))?;
|
|
} else {
|
|
write!(f, "{} ({})", fmt_for_failure(&self), fmt_rolls(&self))?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
trait DieRoller {
|
|
fn roll_number(&mut self, sides: i32) -> i32;
|
|
}
|
|
|
|
///A version of DieRoller that uses a rand::Rng to roll numbers.
|
|
struct RngDieRoller<R: rand::Rng>(R);
|
|
|
|
impl<R: rand::Rng> DieRoller for RngDieRoller<R> {
|
|
fn roll_number(&mut self, sides: i32) -> i32 {
|
|
self.0.gen_range(1..=sides)
|
|
}
|
|
}
|
|
|
|
///Roll a die in the pool, that "explodes" on a given number or higher. Dice will keep
|
|
///being rolled until the result is lower than the explode number, which is normally 10.
|
|
///Statistically speaking, usually one result will be returned from this function.
|
|
fn roll_exploding_die<R: DieRoller>(
|
|
roller: &mut R,
|
|
sides: i32,
|
|
explode_on_or_higher: i32,
|
|
) -> Vec<i32> {
|
|
let mut results = vec![];
|
|
loop {
|
|
let roll = roller.roll_number(sides);
|
|
results.push(roll);
|
|
if roll < explode_on_or_higher {
|
|
break;
|
|
}
|
|
}
|
|
results
|
|
}
|
|
|
|
///A die with the rote quality is re-rolled once if the roll fails. Otherwise, it obeys
|
|
///all normal rules (re-roll 10s). Re-rolled dice are appended to the result set, so we
|
|
///can keep track of the actual dice that were rolled.
|
|
fn roll_rote_die<R: DieRoller>(roller: &mut R, sides: i32, success_on: i32) -> Vec<i32> {
|
|
let mut rolls = roll_exploding_die(roller, sides, 10);
|
|
|
|
if rolls.len() == 1 && rolls[0] < success_on {
|
|
rolls.append(&mut roll_exploding_die(roller, sides, 10));
|
|
}
|
|
|
|
rolls
|
|
}
|
|
|
|
///Roll a single die in the pool, potentially rolling additional dice depending on pool
|
|
///behavior. The default ten-again will "explode" the die if the result is 10 (repeatedly, if
|
|
///there are multiple 10s). Nine- and eight-again will explode similarly if the result is
|
|
///at least that number. Rote quality will re-roll a failure once, while also exploding
|
|
///on 10. The function returns a Vec of all rolled dice (usually 1).
|
|
fn roll_die<R: DieRoller>(roller: &mut R, pool: &DicePool) -> Vec<i32> {
|
|
let mut results = vec![];
|
|
let sides = pool.sides;
|
|
let success_on = pool.modifiers.success_on;
|
|
|
|
match pool.modifiers.quality {
|
|
DicePoolQuality::TenAgain => results.append(&mut roll_exploding_die(roller, sides, 10)),
|
|
DicePoolQuality::NineAgain => results.append(&mut roll_exploding_die(roller, sides, 9)),
|
|
DicePoolQuality::EightAgain => results.append(&mut roll_exploding_die(roller, sides, 8)),
|
|
DicePoolQuality::Rote => results.append(&mut roll_rote_die(roller, sides, success_on)),
|
|
DicePoolQuality::ChanceDie | DicePoolQuality::NoExplode => {
|
|
results.push(roller.roll_number(sides))
|
|
}
|
|
}
|
|
|
|
results
|
|
}
|
|
|
|
fn roll_dice<'a, R: DieRoller>(pool: &DicePool, num_dice: i32, roller: &mut R) -> Vec<i32> {
|
|
(0..num_dice)
|
|
.flat_map(|_| roll_die(roller, &pool))
|
|
.collect()
|
|
}
|
|
|
|
///Roll the dice in a dice pool, according to behavior documented in the various rolling
|
|
///methods.
|
|
pub async fn roll_pool(pool: &DicePoolWithContext<'_>) -> Result<RolledDicePool, BotError> {
|
|
if pool.0.amounts.len() > 100 {
|
|
return Err(DiceRollingError::ExpressionTooLarge.into());
|
|
}
|
|
|
|
let num_dice = crate::logic::calculate_dice_amount(&pool.0.amounts, &pool.1).await?;
|
|
let mut roller = RngDieRoller(rand::thread_rng());
|
|
|
|
if num_dice > 0 {
|
|
let rolls = roll_dice(&pool.0, num_dice, &mut roller);
|
|
Ok(RolledDicePool::from(&pool.0, num_dice, rolls))
|
|
} else {
|
|
let chance_die = DicePool::chance_die();
|
|
let pool = DicePoolWithContext(&chance_die, &pool.1);
|
|
let rolls = roll_dice(&pool.0, 1, &mut roller);
|
|
Ok(RolledDicePool::from(&pool.0, 1, rolls))
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use crate::db::sqlite::Database;
|
|
use crate::db::Variables;
|
|
use url::Url;
|
|
|
|
macro_rules! dummy_room {
|
|
() => {
|
|
crate::context::RoomContext {
|
|
id: &matrix_sdk::ruma::room_id!("!fakeroomid:example.com"),
|
|
display_name: "displayname".to_owned(),
|
|
secure: false,
|
|
}
|
|
};
|
|
}
|
|
|
|
///Instead of being random, generate a series of numbers we have complete
|
|
///control over.
|
|
struct SequentialDieRoller {
|
|
results: Vec<i32>,
|
|
position: usize,
|
|
}
|
|
|
|
impl SequentialDieRoller {
|
|
fn new(results: Vec<i32>) -> SequentialDieRoller {
|
|
SequentialDieRoller {
|
|
results: results,
|
|
position: 0,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl DieRoller for SequentialDieRoller {
|
|
fn roll_number(&mut self, _sides: i32) -> i32 {
|
|
let roll = self.results[self.position];
|
|
self.position += 1;
|
|
roll
|
|
}
|
|
}
|
|
|
|
//Sanity checks
|
|
#[test]
|
|
pub fn chance_die_has_success_on_10_test() {
|
|
assert_eq!(10, DicePool::chance_die().modifiers.success_on);
|
|
}
|
|
|
|
#[test]
|
|
pub fn non_chance_die_has_success_on_8_test() {
|
|
fn check_success_on(quality: DicePoolQuality) {
|
|
let modifiers = DicePoolModifiers::custom_quality(quality);
|
|
let amount = vec![Amount {
|
|
operator: Operator::Plus,
|
|
element: Element::Number(1),
|
|
}];
|
|
assert_eq!(8, DicePool::new(amount, modifiers).modifiers.success_on);
|
|
}
|
|
|
|
check_success_on(DicePoolQuality::TenAgain);
|
|
check_success_on(DicePoolQuality::NineAgain);
|
|
check_success_on(DicePoolQuality::EightAgain);
|
|
check_success_on(DicePoolQuality::Rote);
|
|
check_success_on(DicePoolQuality::NoExplode);
|
|
}
|
|
|
|
//Dice rolling tests.
|
|
#[test]
|
|
pub fn ten_again_test() {
|
|
let mut roller = SequentialDieRoller::new(vec![10, 8, 1]);
|
|
let rolls = roll_exploding_die(&mut roller, 10, 10);
|
|
assert_eq!(vec![10, 8], rolls);
|
|
}
|
|
|
|
#[test]
|
|
pub fn nine_again_test() {
|
|
let mut roller = SequentialDieRoller::new(vec![10, 9, 8, 1]);
|
|
let rolls = roll_exploding_die(&mut roller, 10, 9);
|
|
assert_eq!(vec![10, 9, 8], rolls);
|
|
}
|
|
|
|
#[test]
|
|
pub fn eight_again_test() {
|
|
let mut roller = SequentialDieRoller::new(vec![10, 9, 8, 8, 1]);
|
|
let rolls = roll_exploding_die(&mut roller, 10, 8);
|
|
assert_eq!(vec![10, 9, 8, 8, 1], rolls);
|
|
}
|
|
|
|
#[test]
|
|
pub fn rote_quality_fail_then_succeed_test() {
|
|
let mut roller = SequentialDieRoller::new(vec![5, 8, 1]);
|
|
let rolls = roll_rote_die(&mut roller, 10, 8);
|
|
assert_eq!(vec![5, 8], rolls);
|
|
}
|
|
|
|
#[test]
|
|
pub fn rote_quality_fail_twice_test() {
|
|
let mut roller = SequentialDieRoller::new(vec![5, 6, 10]);
|
|
let rolls = roll_rote_die(&mut roller, 10, 8);
|
|
assert_eq!(vec![5, 6], rolls);
|
|
}
|
|
|
|
#[test]
|
|
pub fn rote_quality_fail_then_explode_test() {
|
|
let mut roller = SequentialDieRoller::new(vec![5, 10, 8, 1]);
|
|
let rolls = roll_rote_die(&mut roller, 10, 8);
|
|
assert_eq!(vec![5, 10, 8], rolls);
|
|
}
|
|
|
|
#[test]
|
|
pub fn rote_quality_obeys_success_on_test() {
|
|
//With success_on = 8, should only roll once.
|
|
let mut roller = SequentialDieRoller::new(vec![8, 7]);
|
|
let rolls = roll_rote_die(&mut roller, 10, 8);
|
|
assert_eq!(vec![8], rolls);
|
|
|
|
//With success_on = 9, we should re-roll if it's an 8.
|
|
roller = SequentialDieRoller::new(vec![8, 7]);
|
|
let rolls = roll_rote_die(&mut roller, 10, 9);
|
|
assert_eq!(vec![8, 7], rolls);
|
|
}
|
|
|
|
#[test]
|
|
fn dice_pool_modifiers_chance_die_test() {
|
|
let modifiers = DicePoolModifiers::custom_quality(DicePoolQuality::ChanceDie);
|
|
assert_eq!(10, modifiers.success_on);
|
|
}
|
|
|
|
#[test]
|
|
fn dice_pool_modifiers_default_sanity_check() {
|
|
let modifiers = DicePoolModifiers::default();
|
|
assert_eq!(8, modifiers.success_on);
|
|
assert_eq!(5, modifiers.exceptional_on);
|
|
assert_eq!(DicePoolQuality::TenAgain, modifiers.quality);
|
|
}
|
|
|
|
#[test]
|
|
pub fn no_explode_roll_test() {
|
|
let pool = DicePool::easy_pool(1, DicePoolQuality::NoExplode);
|
|
let mut roller = SequentialDieRoller::new(vec![10, 8]);
|
|
let roll = roll_dice(&pool, 1, &mut roller);
|
|
assert_eq!(vec![10], roll);
|
|
}
|
|
|
|
#[test]
|
|
fn number_of_dice_equality_test() {
|
|
let num_dice = 5;
|
|
let rolls = vec![1, 2, 3, 4, 5];
|
|
let pool = DicePool::easy_pool(5, DicePoolQuality::TenAgain);
|
|
let rolled_pool = RolledDicePool::from(&pool, num_dice, rolls);
|
|
assert_eq!(5, rolled_pool.num_dice);
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
|
|
async fn rejects_large_expression_test() {
|
|
let db_path = tempfile::NamedTempFile::new_in(".").unwrap();
|
|
let homeserver = Url::parse("http://example.com").unwrap();
|
|
let db = Database::new(db_path.path().to_str().unwrap())
|
|
.await
|
|
.unwrap();
|
|
|
|
let ctx = Context {
|
|
account: crate::models::Account::default(),
|
|
db: db,
|
|
matrix_client: matrix_sdk::Client::new(homeserver).await.unwrap(),
|
|
origin_room: dummy_room!(),
|
|
active_room: dummy_room!(),
|
|
username: "username",
|
|
message_body: "message",
|
|
};
|
|
|
|
let mut amounts = vec![];
|
|
|
|
for _ in 0..500 {
|
|
amounts.push(Amount {
|
|
operator: Operator::Plus,
|
|
element: Element::Number(1),
|
|
});
|
|
}
|
|
|
|
let pool = DicePool::new(amounts, DicePoolModifiers::default());
|
|
let pool_with_ctx = DicePoolWithContext(&pool, &ctx);
|
|
let result = roll_pool(&pool_with_ctx).await;
|
|
assert!(matches!(
|
|
result,
|
|
Err(BotError::DiceRollingError(
|
|
DiceRollingError::ExpressionTooLarge
|
|
))
|
|
));
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
|
|
async fn converts_to_chance_die_test() {
|
|
let db_path = tempfile::NamedTempFile::new_in(".").unwrap();
|
|
crate::db::sqlite::migrator::migrate(db_path.path().to_str().unwrap())
|
|
.await
|
|
.unwrap();
|
|
|
|
let db = Database::new(db_path.path().to_str().unwrap())
|
|
.await
|
|
.unwrap();
|
|
|
|
let homeserver = Url::parse("http://example.com").unwrap();
|
|
let ctx = Context {
|
|
account: crate::models::Account::default(),
|
|
db: db,
|
|
matrix_client: matrix_sdk::Client::new(homeserver).await.unwrap(),
|
|
origin_room: dummy_room!(),
|
|
active_room: dummy_room!(),
|
|
username: "username",
|
|
message_body: "message",
|
|
};
|
|
|
|
let mut amounts = vec![];
|
|
|
|
amounts.push(Amount {
|
|
operator: Operator::Plus,
|
|
element: Element::Number(-1),
|
|
});
|
|
|
|
let pool = DicePool::new(amounts, DicePoolModifiers::default());
|
|
let pool_with_ctx = DicePoolWithContext(&pool, &ctx);
|
|
let result = roll_pool(&pool_with_ctx).await;
|
|
assert!(result.is_ok());
|
|
|
|
let roll = result.unwrap();
|
|
assert_eq!(DicePoolQuality::ChanceDie, roll.modifiers.quality);
|
|
assert_eq!(1, roll.num_dice);
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
|
|
async fn can_resolve_variables_test() {
|
|
let db_path = tempfile::NamedTempFile::new_in(".").unwrap();
|
|
crate::db::sqlite::migrator::migrate(db_path.path().to_str().unwrap())
|
|
.await
|
|
.unwrap();
|
|
|
|
let db = Database::new(db_path.path().to_str().unwrap())
|
|
.await
|
|
.unwrap();
|
|
|
|
let homeserver = Url::parse("http://example.com").unwrap();
|
|
let ctx = Context {
|
|
account: crate::models::Account::default(),
|
|
db: db.clone(),
|
|
matrix_client: matrix_sdk::Client::new(homeserver).await.unwrap(),
|
|
origin_room: dummy_room!(),
|
|
active_room: dummy_room!(),
|
|
username: "username",
|
|
message_body: "message",
|
|
};
|
|
|
|
db.set_user_variable(
|
|
&ctx.username,
|
|
&ctx.origin_room.id.as_str(),
|
|
"myvariable",
|
|
10,
|
|
)
|
|
.await
|
|
.expect("could not set myvariable to 10");
|
|
|
|
let amounts = vec![Amount {
|
|
operator: Operator::Plus,
|
|
element: Element::Variable("myvariable".to_owned()),
|
|
}];
|
|
|
|
let pool = DicePool::new(amounts, DicePoolModifiers::default());
|
|
|
|
assert_eq!(
|
|
crate::logic::calculate_dice_amount(&pool.amounts, &ctx)
|
|
.await
|
|
.unwrap(),
|
|
10
|
|
);
|
|
}
|
|
|
|
//DicePool tests
|
|
#[test]
|
|
fn easy_pool_chance_die_test() {
|
|
let pool = DicePool::easy_pool(1, DicePoolQuality::ChanceDie);
|
|
assert_eq!(10, pool.modifiers.success_on);
|
|
}
|
|
|
|
#[test]
|
|
fn easy_pool_quality_test() {
|
|
fn check_quality(quality: DicePoolQuality) {
|
|
let pool = DicePool::easy_pool(1, quality);
|
|
assert_eq!(quality, pool.modifiers.quality);
|
|
}
|
|
|
|
check_quality(DicePoolQuality::TenAgain);
|
|
check_quality(DicePoolQuality::NineAgain);
|
|
check_quality(DicePoolQuality::EightAgain);
|
|
check_quality(DicePoolQuality::Rote);
|
|
check_quality(DicePoolQuality::ChanceDie);
|
|
check_quality(DicePoolQuality::NoExplode);
|
|
}
|
|
|
|
#[test]
|
|
fn is_successful_on_equal_test() {
|
|
let result = DicePoolRoll {
|
|
rolls: vec![8],
|
|
modifiers: DicePoolModifiers {
|
|
exceptional_on: 5,
|
|
success_on: 8,
|
|
quality: DicePoolQuality::TenAgain,
|
|
},
|
|
};
|
|
|
|
assert_eq!(1, result.successes());
|
|
}
|
|
|
|
#[test]
|
|
fn chance_die_success_test() {
|
|
let result = DicePoolRoll {
|
|
rolls: vec![10],
|
|
modifiers: DicePoolModifiers {
|
|
exceptional_on: 5,
|
|
success_on: 10,
|
|
quality: DicePoolQuality::ChanceDie,
|
|
},
|
|
};
|
|
|
|
assert_eq!(1, result.successes());
|
|
}
|
|
|
|
#[test]
|
|
fn chance_die_fail_test() {
|
|
let result = DicePoolRoll {
|
|
rolls: vec![9],
|
|
modifiers: DicePoolModifiers {
|
|
exceptional_on: 5,
|
|
success_on: 10,
|
|
quality: DicePoolQuality::ChanceDie,
|
|
},
|
|
};
|
|
|
|
assert_eq!(0, result.successes());
|
|
}
|
|
|
|
#[test]
|
|
fn is_exceptional_test() {
|
|
let result = DicePoolRoll {
|
|
rolls: vec![8, 8, 9, 10, 8],
|
|
modifiers: DicePoolModifiers {
|
|
exceptional_on: 5,
|
|
success_on: 8,
|
|
quality: DicePoolQuality::TenAgain,
|
|
},
|
|
};
|
|
|
|
assert_eq!(5, result.successes());
|
|
assert_eq!(true, result.is_exceptional());
|
|
}
|
|
|
|
#[test]
|
|
fn is_not_exceptional_test() {
|
|
let result = DicePoolRoll {
|
|
rolls: vec![8, 8, 9, 10],
|
|
modifiers: DicePoolModifiers::default(),
|
|
};
|
|
|
|
assert_eq!(4, result.successes());
|
|
assert_eq!(false, result.is_exceptional());
|
|
}
|
|
|
|
//Format tests
|
|
#[test]
|
|
fn formats_rolled_dice_pool_single_die() {
|
|
let pool = DicePool::easy_pool(5, DicePoolQuality::TenAgain);
|
|
let rolled_pool = RolledDicePool::from(&pool, 1, vec![1]);
|
|
let message = format!("{}", rolled_pool);
|
|
assert!(message.starts_with("1 die"));
|
|
}
|
|
|
|
#[test]
|
|
fn formats_rolled_dice_pool_multiple_dice() {
|
|
let pool = DicePool::easy_pool(5, DicePoolQuality::TenAgain);
|
|
let rolled_pool = RolledDicePool::from(&pool, 2, vec![1, 2]);
|
|
let message = format!("{}", rolled_pool);
|
|
assert!(message.starts_with("2 dice"));
|
|
}
|
|
|
|
#[test]
|
|
fn formats_rolled_dice_pool_zero_dice() {
|
|
let pool = DicePool::easy_pool(5, DicePoolQuality::TenAgain);
|
|
let rolled_pool = RolledDicePool::from(&pool, 0, vec![]);
|
|
let message = format!("{}", rolled_pool);
|
|
assert!(message.starts_with("0 dice"));
|
|
}
|
|
|
|
#[test]
|
|
fn formats_dramatic_failure_test() {
|
|
let result = DicePoolRoll {
|
|
rolls: vec![1],
|
|
modifiers: DicePoolModifiers::custom_quality(DicePoolQuality::ChanceDie),
|
|
};
|
|
|
|
assert_eq!("dramatic failure!", fmt_for_failure(&result));
|
|
}
|
|
|
|
#[test]
|
|
fn formats_regular_failure_when_not_chance_die_test() {
|
|
let result = DicePoolRoll {
|
|
rolls: vec![1],
|
|
modifiers: DicePoolModifiers {
|
|
quality: DicePoolQuality::TenAgain,
|
|
exceptional_on: 5,
|
|
success_on: 10,
|
|
},
|
|
};
|
|
|
|
assert_eq!("failure!", fmt_for_failure(&result));
|
|
}
|
|
|
|
#[test]
|
|
fn formats_lots_of_dice_test() {
|
|
let result = DicePoolRoll {
|
|
modifiers: DicePoolModifiers::default(),
|
|
rolls: vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9],
|
|
};
|
|
|
|
assert_eq!(
|
|
"1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, and 4 more",
|
|
fmt_rolls(&result)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn shows_more_than_10_dice_test() {
|
|
//Make sure we display more than 10 dice when below the display limit (15).
|
|
let result = DicePoolRoll {
|
|
modifiers: DicePoolModifiers::default(),
|
|
rolls: vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14],
|
|
};
|
|
|
|
assert_eq!(
|
|
"1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14",
|
|
fmt_rolls(&result)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn shows_exactly_15_dice_test() {
|
|
//If we are at format limit (15), make sure all are shown
|
|
let result = DicePoolRoll {
|
|
modifiers: DicePoolModifiers::default(),
|
|
rolls: vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
|
|
};
|
|
|
|
assert_eq!(
|
|
"1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15",
|
|
fmt_rolls(&result)
|
|
);
|
|
}
|
|
}
|