776 lines
24 KiB
Rust
776 lines
24 KiB
Rust
use crate::context::Context;
|
|
use crate::db::Variables;
|
|
use crate::error::{BotError, DiceRollingError};
|
|
use crate::logic::calculate_single_die_amount;
|
|
use crate::parser::dice::{Amount, DiceParsingError, Element};
|
|
use rand::rngs::StdRng;
|
|
use rand::Rng;
|
|
use rand::SeedableRng;
|
|
use std::convert::TryFrom;
|
|
use std::fmt;
|
|
|
|
/// A planned dice roll.
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub struct DiceRoll {
|
|
pub amount: Amount,
|
|
pub modifier: DiceRollModifier,
|
|
}
|
|
|
|
pub struct DiceRollWithContext<'a>(pub &'a DiceRoll, pub &'a Context<'a>);
|
|
|
|
/// Potential modifier on the die roll to be made.
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum DiceRollModifier {
|
|
/// No bonuses or penalties.
|
|
Normal,
|
|
|
|
/// Roll one extra die and pick the lower of two results.
|
|
OneBonus,
|
|
|
|
/// Roll two extra dice and pick the lower of all results.
|
|
TwoBonus,
|
|
|
|
/// Roll one extra die and pick the higher of two results.
|
|
OnePenalty,
|
|
|
|
/// Roll two extra dice and pick the higher of all results.
|
|
TwoPenalty,
|
|
}
|
|
|
|
impl fmt::Display for DiceRollModifier {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
let message = match self {
|
|
Self::Normal => "no modifiers",
|
|
Self::OneBonus => "one bonus die",
|
|
Self::TwoBonus => "two bonus dice",
|
|
Self::OnePenalty => "one penalty die",
|
|
Self::TwoPenalty => "two penalty dice",
|
|
};
|
|
|
|
write!(f, "{}", message)?;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
/// The outcome of a die roll, either some kind of success or failure.
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum RollResult {
|
|
/// Basic success. The rolled number was equal to or less than the target number.
|
|
Success,
|
|
|
|
/// Hard success means the rolled number was equal to or less than
|
|
/// the target number divided by 2 (rounded down).
|
|
HardSuccess,
|
|
|
|
/// Extreme success means the rolled number was equal to or less
|
|
/// than the target number divided by 5 (rounded down).
|
|
ExtremeSuccess,
|
|
|
|
/// A critical success occurs on a roll of 1.
|
|
CriticalSuccess,
|
|
|
|
/// A basic failure means that the roll was above the target number.
|
|
Failure,
|
|
|
|
/// A fumble occurs if the target number is below 50 and the roll
|
|
/// was 96 - 100, OR if the roll result was 100. This means lower
|
|
/// target numbers are more likely to produce a fumble.
|
|
Fumble,
|
|
}
|
|
|
|
impl fmt::Display for RollResult {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
let message = match self {
|
|
Self::Success => "success!",
|
|
Self::HardSuccess => "hard success!",
|
|
Self::ExtremeSuccess => "extreme success!",
|
|
Self::CriticalSuccess => "critical success!",
|
|
Self::Failure => "failure!",
|
|
Self::Fumble => "fumble!",
|
|
};
|
|
|
|
write!(f, "{}", message)?;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
/// A struct wrapping the target and the actual dice roll result. This
|
|
/// is done for formatting purposes, so we can display the target
|
|
/// number (calculated from resolving variables) separately from the
|
|
/// result.
|
|
pub struct ExecutedDiceRoll {
|
|
/// The number we must meet for the roll to be considered a
|
|
/// success.
|
|
pub target: u32,
|
|
|
|
/// Stored for informational purposes in display.
|
|
pub modifier: DiceRollModifier,
|
|
|
|
/// The actual roll result.
|
|
pub roll: RolledDice,
|
|
}
|
|
|
|
impl fmt::Display for ExecutedDiceRoll {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
let message = format!("target: {}, with {}", self.target, self.modifier);
|
|
write!(f, "{}", message)?;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
/// A struct wrapping the target and the actual advancement roll
|
|
/// result. This is done for formatting purposes, so we can display
|
|
/// the target number (calculated from resolving variables) separately
|
|
/// from the result.
|
|
pub struct ExecutedAdvancementRoll {
|
|
/// The number we must exceed for the roll to be considered a
|
|
/// success.
|
|
pub target: u32,
|
|
|
|
/// The actual roll result.
|
|
pub roll: RolledAdvancement,
|
|
}
|
|
|
|
impl fmt::Display for ExecutedAdvancementRoll {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
let message = format!("target: {}", self.target);
|
|
write!(f, "{}", message)?;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
//TODO need to keep track of all rolled numbers for informational purposes!
|
|
/// The outcome of a roll.
|
|
pub struct RolledDice {
|
|
/// The d100 result actually rolled.
|
|
num_rolled: u32,
|
|
|
|
/// The number we must meet for the roll to be considered a
|
|
/// success.
|
|
target: u32,
|
|
}
|
|
|
|
impl RolledDice {
|
|
/// Calculate what type of success or failure this roll is.
|
|
/// Consult the RollResult enum for descriptions of what each
|
|
/// result requires.
|
|
pub fn result(&self) -> RollResult {
|
|
let hard_target = self.target / 2u32;
|
|
let extreme_target = self.target / 5u32;
|
|
if (self.target < 50 && self.num_rolled > 95) || self.num_rolled == 100 {
|
|
RollResult::Fumble
|
|
} else if self.num_rolled == 1 {
|
|
RollResult::CriticalSuccess
|
|
} else if self.num_rolled <= extreme_target {
|
|
RollResult::ExtremeSuccess
|
|
} else if self.num_rolled <= hard_target {
|
|
RollResult::HardSuccess
|
|
} else if self.num_rolled <= self.target {
|
|
RollResult::Success
|
|
} else {
|
|
RollResult::Failure
|
|
}
|
|
}
|
|
}
|
|
|
|
impl fmt::Display for RolledDice {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
let message = format!(
|
|
"{} against {}: {}",
|
|
self.num_rolled,
|
|
self.target,
|
|
self.result()
|
|
);
|
|
write!(f, "{}", message)?;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
/// A planned advancement roll, where the target number is the
|
|
/// existing skill amount.
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub struct AdvancementRoll {
|
|
/// The amount (0 to 100) of the existing skill. We must beat this
|
|
/// target number to advance the skill, or roll above a 95.
|
|
pub existing_skill: Amount,
|
|
}
|
|
|
|
impl fmt::Display for AdvancementRoll {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
let message = format!("advancement for skill of {:?}", self.existing_skill);
|
|
write!(f, "{}", message)?;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
/// A struct holding an advancement roll and the context, so we can
|
|
/// translate variables to numbers.
|
|
pub struct AdvancementRollWithContext<'a>(pub &'a AdvancementRoll, pub &'a Context<'a>);
|
|
|
|
/// A completed advancement roll.
|
|
pub struct RolledAdvancement {
|
|
existing_skill: u32,
|
|
num_rolled: u32,
|
|
advancement: u32,
|
|
successful: bool,
|
|
}
|
|
|
|
impl RolledAdvancement {
|
|
/// The new skill amount, which will be the same if the roll was a
|
|
/// failure.
|
|
pub fn new_skill_amount(&self) -> u32 {
|
|
self.existing_skill + self.advancement
|
|
}
|
|
|
|
/// How much the skill advanced (1 to 10). 0 if the advancement
|
|
/// roll failed.
|
|
pub fn advancement(&self) -> u32 {
|
|
self.advancement
|
|
}
|
|
|
|
/// Whether or not the advancement roll was successful.
|
|
pub fn successful(&self) -> bool {
|
|
self.successful
|
|
}
|
|
}
|
|
|
|
impl fmt::Display for RolledAdvancement {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
let message = if self.successful {
|
|
format!(
|
|
"success! new skill is {} (advanced by {}).",
|
|
self.new_skill_amount(),
|
|
self.advancement
|
|
)
|
|
} else {
|
|
format!("failure! skill remains at {}", self.existing_skill)
|
|
};
|
|
|
|
write!(
|
|
f,
|
|
"rolled {} against {}: {}",
|
|
self.num_rolled, self.existing_skill, message
|
|
)?;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
/// This is a trait so we can inject controlled dice rolls in unit
|
|
/// tests.
|
|
trait DieRoller {
|
|
fn roll(&mut self) -> u32;
|
|
}
|
|
|
|
/// Macro to determine if an Amount is a variable.
|
|
macro_rules! is_variable {
|
|
($existing_skill:ident) => {
|
|
matches!(
|
|
$existing_skill,
|
|
Amount {
|
|
element: Element::Variable(_),
|
|
..
|
|
}
|
|
)
|
|
};
|
|
}
|
|
|
|
/// A die roller than can have an RNG implementation injected, but
|
|
/// must be thread-safe. Required for the async dice rolling code.
|
|
struct RngDieRoller<R: Rng + ?Sized + Send>(R);
|
|
|
|
impl<R: Rng + ?Sized + Send> DieRoller for RngDieRoller<R> {
|
|
fn roll(&mut self) -> u32 {
|
|
self.0.gen_range(0..=9)
|
|
}
|
|
}
|
|
|
|
/// Roll a single percentile die according to the rules. We cannot
|
|
/// simply roll a d100 due to the way the game calculates roll results
|
|
/// with bonus/penalty dice. The unit roll (ones place) is added to
|
|
/// the tens roll, unless both results are 0, in which case the result
|
|
/// is 100.
|
|
fn roll_percentile_dice<R: DieRoller>(roller: &mut R, unit_roll: u32) -> u32 {
|
|
let tens_roll = roller.roll() * 10;
|
|
|
|
if tens_roll == 0 && unit_roll == 0 {
|
|
100
|
|
} else {
|
|
tens_roll + unit_roll
|
|
}
|
|
}
|
|
|
|
fn roll_regular_dice<R: DieRoller>(
|
|
modifier: &DiceRollModifier,
|
|
target: u32,
|
|
roller: &mut R,
|
|
) -> RolledDice {
|
|
use DiceRollModifier::*;
|
|
|
|
let num_rolls = match modifier {
|
|
Normal => 1,
|
|
OneBonus | OnePenalty => 2,
|
|
TwoBonus | TwoPenalty => 3,
|
|
};
|
|
|
|
let unit_roll = roller.roll();
|
|
|
|
let rolls: Vec<u32> = (0..num_rolls)
|
|
.map(|_| roll_percentile_dice(roller, unit_roll))
|
|
.collect();
|
|
|
|
let num_rolled = match modifier {
|
|
Normal => rolls.first(),
|
|
OneBonus | TwoBonus => rolls.iter().min(),
|
|
OnePenalty | TwoPenalty => rolls.iter().max(),
|
|
}
|
|
.unwrap();
|
|
|
|
RolledDice {
|
|
num_rolled: *num_rolled,
|
|
target: target,
|
|
}
|
|
}
|
|
|
|
fn roll_advancement_dice<R: DieRoller>(target: u32, roller: &mut R) -> RolledAdvancement {
|
|
let unit_roll = roller.roll();
|
|
let percentile_roll = roll_percentile_dice(roller, unit_roll);
|
|
|
|
if percentile_roll > target || percentile_roll > 95 {
|
|
RolledAdvancement {
|
|
num_rolled: percentile_roll,
|
|
existing_skill: target,
|
|
advancement: roller.roll() + 1,
|
|
successful: true,
|
|
}
|
|
} else {
|
|
RolledAdvancement {
|
|
num_rolled: percentile_roll,
|
|
existing_skill: target,
|
|
advancement: 0,
|
|
successful: false,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Make a roll with a target number and potential modifier. In a
|
|
/// normal roll, only one percentile die is rolled (1d100). With
|
|
/// bonuses or penalties, more dice are rolled, and either the lowest
|
|
/// (in case of bonus) or highest (in case of penalty) result is
|
|
/// picked. Rolls are not simply d100; the unit roll (ones place) is
|
|
/// rolled separately from the tens place, and then the unit number is
|
|
/// added to each potential roll before picking the lowest/highest
|
|
/// result.
|
|
pub async fn regular_roll(
|
|
roll_with_ctx: &DiceRollWithContext<'_>,
|
|
) -> Result<ExecutedDiceRoll, BotError> {
|
|
let target = calculate_single_die_amount(&roll_with_ctx.0.amount, roll_with_ctx.1).await?;
|
|
let target = u32::try_from(target).map_err(|_| DiceRollingError::InvalidAmount)?;
|
|
|
|
let mut roller = RngDieRoller::<StdRng>(SeedableRng::from_entropy());
|
|
let rolled_dice = roll_regular_dice(&roll_with_ctx.0.modifier, target, &mut roller);
|
|
|
|
Ok(ExecutedDiceRoll {
|
|
target,
|
|
modifier: roll_with_ctx.0.modifier,
|
|
roll: rolled_dice,
|
|
})
|
|
}
|
|
|
|
async fn update_skill(ctx: &Context<'_>, variable: &str, value: u32) -> Result<(), BotError> {
|
|
use std::convert::TryInto;
|
|
let value: i32 = value.try_into()?;
|
|
ctx.db
|
|
.set_user_variable(
|
|
&ctx.username,
|
|
&ctx.active_room_id().as_str(),
|
|
variable,
|
|
value,
|
|
)
|
|
.await?;
|
|
Ok(())
|
|
}
|
|
|
|
fn extract_variable(amount: &Amount) -> Result<&str, DiceParsingError> {
|
|
match amount.element {
|
|
Element::Variable(ref varname) => Ok(&varname[..]),
|
|
_ => Err(DiceParsingError::WrongElementType),
|
|
}
|
|
}
|
|
pub async fn advancement_roll(
|
|
roll_with_ctx: &AdvancementRollWithContext<'_>,
|
|
) -> Result<ExecutedAdvancementRoll, BotError> {
|
|
let existing_skill = &roll_with_ctx.0.existing_skill;
|
|
let target = calculate_single_die_amount(existing_skill, roll_with_ctx.1).await?;
|
|
|
|
let target = u32::try_from(target).map_err(|_| DiceRollingError::InvalidAmount)?;
|
|
|
|
if target > 100 {
|
|
return Err(DiceRollingError::InvalidAmount.into());
|
|
}
|
|
|
|
let mut roller = RngDieRoller::<StdRng>(SeedableRng::from_entropy());
|
|
let roll = roll_advancement_dice(target, &mut roller);
|
|
|
|
drop(roller);
|
|
|
|
if roll.successful && is_variable!(existing_skill) {
|
|
let variable_name: &str = extract_variable(existing_skill)?;
|
|
update_skill(roll_with_ctx.1, variable_name, roll.new_skill_amount()).await?;
|
|
}
|
|
|
|
Ok(ExecutedAdvancementRoll { target, roll })
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use crate::db::sqlite::Database;
|
|
use crate::parser::dice::{Amount, Element, Operator};
|
|
use url::Url;
|
|
use matrix_sdk::ruma::room_id;
|
|
|
|
macro_rules! dummy_room {
|
|
() => {
|
|
crate::context::RoomContext {
|
|
id: &room_id!("!fakeroomid:example.com"),
|
|
display_name: "displayname".to_owned(),
|
|
secure: false,
|
|
}
|
|
};
|
|
}
|
|
|
|
/// Generate a series of numbers manually for testing. For this
|
|
/// die system, the first roll in the Vec should be the unit roll,
|
|
/// and any subsequent rolls should be the tens place roll. The
|
|
/// results rolled must come from a d10 (0 to 9).
|
|
struct SequentialDieRoller {
|
|
results: Vec<u32>,
|
|
position: usize,
|
|
}
|
|
|
|
impl SequentialDieRoller {
|
|
fn new(results: Vec<u32>) -> SequentialDieRoller {
|
|
SequentialDieRoller {
|
|
results,
|
|
position: 0,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl DieRoller for SequentialDieRoller {
|
|
fn roll(&mut self) -> u32 {
|
|
let roll = self.results[self.position];
|
|
self.position += 1;
|
|
roll
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn extract_variable_gets_variable_name() {
|
|
let amount = Amount {
|
|
operator: Operator::Plus,
|
|
element: Element::Variable("abc".to_string()),
|
|
};
|
|
|
|
let result = extract_variable(&amount);
|
|
|
|
assert!(result.is_ok());
|
|
assert_eq!(result.unwrap(), "abc");
|
|
}
|
|
|
|
#[test]
|
|
fn extract_variable_fails_on_number() {
|
|
let result = extract_variable(&Amount {
|
|
operator: Operator::Plus,
|
|
element: Element::Number(1),
|
|
});
|
|
|
|
assert!(result.is_err());
|
|
assert!(matches!(result, Err(DiceParsingError::WrongElementType)));
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
|
|
async fn regular_roll_rejects_negative_numbers() {
|
|
let roll = DiceRoll {
|
|
amount: Amount {
|
|
operator: Operator::Plus,
|
|
element: Element::Number(-10),
|
|
},
|
|
modifier: DiceRollModifier::Normal,
|
|
};
|
|
|
|
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 roll_with_ctx = DiceRollWithContext(&roll, &ctx);
|
|
let result = regular_roll(&roll_with_ctx).await;
|
|
assert!(result.is_err());
|
|
assert!(matches!(
|
|
result,
|
|
Err(BotError::DiceRollingError(DiceRollingError::InvalidAmount))
|
|
));
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
|
|
async fn advancement_roll_rejects_negative_numbers() {
|
|
let roll = AdvancementRoll {
|
|
existing_skill: Amount {
|
|
operator: Operator::Plus,
|
|
element: Element::Number(-10),
|
|
},
|
|
};
|
|
|
|
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 roll_with_ctx = AdvancementRollWithContext(&roll, &ctx);
|
|
let result = advancement_roll(&roll_with_ctx).await;
|
|
assert!(result.is_err());
|
|
assert!(matches!(
|
|
result,
|
|
Err(BotError::DiceRollingError(DiceRollingError::InvalidAmount))
|
|
));
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
|
|
async fn advancement_roll_rejects_big_numbers() {
|
|
let roll = AdvancementRoll {
|
|
existing_skill: Amount {
|
|
operator: Operator::Plus,
|
|
element: Element::Number(3000),
|
|
},
|
|
};
|
|
|
|
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 roll_with_ctx = AdvancementRollWithContext(&roll, &ctx);
|
|
let result = advancement_roll(&roll_with_ctx).await;
|
|
assert!(result.is_err());
|
|
assert!(matches!(
|
|
result,
|
|
Err(BotError::DiceRollingError(DiceRollingError::InvalidAmount))
|
|
));
|
|
}
|
|
|
|
#[test]
|
|
fn is_variable_macro_succeds_on_variable() {
|
|
let amount = Amount {
|
|
operator: Operator::Plus,
|
|
element: Element::Variable("abc".to_string()),
|
|
};
|
|
|
|
assert_eq!(is_variable!(amount), true);
|
|
}
|
|
|
|
#[test]
|
|
fn is_variable_macro_fails_on_number() {
|
|
let amount = Amount {
|
|
operator: Operator::Plus,
|
|
element: Element::Number(1),
|
|
};
|
|
|
|
assert_eq!(is_variable!(amount), false);
|
|
}
|
|
|
|
#[test]
|
|
fn regular_roll_succeeds_when_below_target() {
|
|
//Roll 30, succeeding.
|
|
let mut roller = SequentialDieRoller::new(vec![0, 3]);
|
|
let rolled = roll_regular_dice(&DiceRollModifier::Normal, 50, &mut roller);
|
|
assert_eq!(RollResult::Success, rolled.result());
|
|
}
|
|
|
|
#[test]
|
|
fn regular_roll_hard_success_when_rolling_half() {
|
|
//Roll 25, succeeding.
|
|
let mut roller = SequentialDieRoller::new(vec![5, 2]);
|
|
let rolled = roll_regular_dice(&DiceRollModifier::Normal, 50, &mut roller);
|
|
assert_eq!(RollResult::HardSuccess, rolled.result());
|
|
}
|
|
|
|
#[test]
|
|
fn regular_roll_extreme_success_when_rolling_one_fifth() {
|
|
//Roll 10, succeeding extremely.
|
|
let mut roller = SequentialDieRoller::new(vec![0, 1]);
|
|
let rolled = roll_regular_dice(&DiceRollModifier::Normal, 50, &mut roller);
|
|
assert_eq!(RollResult::ExtremeSuccess, rolled.result());
|
|
}
|
|
|
|
#[test]
|
|
fn regular_roll_extreme_success_target_above_100() {
|
|
//Roll 30, succeeding extremely.
|
|
let mut roller = SequentialDieRoller::new(vec![0, 3]);
|
|
let rolled = roll_regular_dice(&DiceRollModifier::Normal, 150, &mut roller);
|
|
assert_eq!(RollResult::ExtremeSuccess, rolled.result());
|
|
}
|
|
|
|
#[test]
|
|
fn regular_roll_critical_success_on_one() {
|
|
//Roll 1.
|
|
let mut roller = SequentialDieRoller::new(vec![1, 0]);
|
|
let rolled = roll_regular_dice(&DiceRollModifier::Normal, 50, &mut roller);
|
|
assert_eq!(RollResult::CriticalSuccess, rolled.result());
|
|
}
|
|
|
|
#[test]
|
|
fn regular_roll_fail_when_above_target() {
|
|
//Roll 60.
|
|
let mut roller = SequentialDieRoller::new(vec![0, 6]);
|
|
let rolled = roll_regular_dice(&DiceRollModifier::Normal, 50, &mut roller);
|
|
assert_eq!(RollResult::Failure, rolled.result());
|
|
}
|
|
|
|
#[test]
|
|
fn regular_roll_is_fumble_when_skill_below_50_and_roll_at_least_96() {
|
|
//Roll 96.
|
|
let mut roller = SequentialDieRoller::new(vec![6, 9]);
|
|
let rolled = roll_regular_dice(&DiceRollModifier::Normal, 49, &mut roller);
|
|
assert_eq!(RollResult::Fumble, rolled.result());
|
|
}
|
|
|
|
#[test]
|
|
fn regular_roll_is_failure_when_skill_at_or_above_50_and_roll_at_least_96() {
|
|
//Roll 96.
|
|
let mut roller = SequentialDieRoller::new(vec![6, 9]);
|
|
let rolled = roll_regular_dice(&DiceRollModifier::Normal, 50, &mut roller);
|
|
assert_eq!(RollResult::Failure, rolled.result());
|
|
|
|
//Roll 96.
|
|
let mut roller = SequentialDieRoller::new(vec![6, 9]);
|
|
let rolled = roll_regular_dice(&DiceRollModifier::Normal, 68, &mut roller);
|
|
assert_eq!(RollResult::Failure, rolled.result());
|
|
}
|
|
|
|
#[test]
|
|
fn regular_roll_always_fumble_on_100() {
|
|
//Roll 100.
|
|
let mut roller = SequentialDieRoller::new(vec![0, 0]);
|
|
let rolled = roll_regular_dice(&DiceRollModifier::Normal, 100, &mut roller);
|
|
assert_eq!(RollResult::Fumble, rolled.result());
|
|
}
|
|
|
|
#[test]
|
|
fn one_penalty_picks_highest_of_two() {
|
|
//Should only roll 30 and 40, not 50.
|
|
let mut roller = SequentialDieRoller::new(vec![0, 3, 4, 5]);
|
|
let rolled = roll_regular_dice(&DiceRollModifier::OnePenalty, 50, &mut roller);
|
|
assert_eq!(40, rolled.num_rolled);
|
|
}
|
|
|
|
#[test]
|
|
fn two_penalty_picks_highest_of_three() {
|
|
//Should only roll 30, 40, 50, and not 60.
|
|
let mut roller = SequentialDieRoller::new(vec![0, 3, 4, 5, 6]);
|
|
let rolled = roll_regular_dice(&DiceRollModifier::TwoPenalty, 50, &mut roller);
|
|
assert_eq!(50, rolled.num_rolled);
|
|
}
|
|
|
|
#[test]
|
|
fn one_bonus_picks_lowest_of_two() {
|
|
//Should only roll 30 and 40, not 20.
|
|
let mut roller = SequentialDieRoller::new(vec![0, 3, 4, 2]);
|
|
let rolled = roll_regular_dice(&DiceRollModifier::OneBonus, 50, &mut roller);
|
|
assert_eq!(30, rolled.num_rolled);
|
|
}
|
|
|
|
#[test]
|
|
fn two_bonus_picks_lowest_of_three() {
|
|
//Should only roll 30, 40, 50, and not 20.
|
|
let mut roller = SequentialDieRoller::new(vec![0, 3, 4, 5, 2]);
|
|
let rolled = roll_regular_dice(&DiceRollModifier::TwoBonus, 50, &mut roller);
|
|
assert_eq!(30, rolled.num_rolled);
|
|
}
|
|
|
|
#[test]
|
|
fn normal_modifier_rolls_once() {
|
|
//Should only roll 30, not 40.
|
|
let mut roller = SequentialDieRoller::new(vec![0, 3, 4]);
|
|
let rolled = roll_regular_dice(&DiceRollModifier::Normal, 50, &mut roller);
|
|
assert_eq!(30, rolled.num_rolled);
|
|
}
|
|
|
|
#[test]
|
|
fn advancement_succeeds_on_above_skill() {
|
|
//Roll 52, then advance skill by 5. (advancement adds +1 to 0-9 roll)
|
|
let mut roller = SequentialDieRoller::new(vec![2, 5, 4]);
|
|
|
|
let rolled = roll_advancement_dice(30, &mut roller);
|
|
assert!(rolled.successful());
|
|
assert_eq!(5, rolled.advancement());
|
|
assert_eq!(35, rolled.new_skill_amount());
|
|
}
|
|
|
|
#[test]
|
|
fn advancement_succeeds_on_above_95() {
|
|
//Roll 96, then advance skill by 1. (advancement adds +1 to 0-9 roll)
|
|
let mut roller = SequentialDieRoller::new(vec![6, 9, 0]);
|
|
|
|
let rolled = roll_advancement_dice(97, &mut roller);
|
|
assert!(rolled.successful());
|
|
assert_eq!(1, rolled.advancement());
|
|
assert_eq!(98, rolled.new_skill_amount());
|
|
}
|
|
|
|
#[test]
|
|
fn advancement_fails_on_below_skill() {
|
|
//Roll 25, failing.
|
|
let mut roller = SequentialDieRoller::new(vec![5, 2]);
|
|
|
|
let rolled = roll_advancement_dice(30, &mut roller);
|
|
assert!(!rolled.successful());
|
|
assert_eq!(0, rolled.advancement());
|
|
}
|
|
}
|