Implement support for user variables in CoC dice rolling.
Also comes with reorganization of the dice rolling code to centralize the variable -> dice amount logic, and changes the way the results of those rolls are displayed.
This commit is contained in:
ProjectMoon
parent
b142b87d65
commit
39e6eb9b46
|
|
@ -1,22 +1,10 @@
|
|||
use crate::context::Context;
|
||||
use crate::db::variables::UserAndRoom;
|
||||
use crate::error::BotError;
|
||||
use crate::error::{BotError, DiceRollingError};
|
||||
use crate::parser::{Amount, Element, Operator};
|
||||
use crate::roll::Rolled;
|
||||
use futures::stream::{self, StreamExt, TryStreamExt};
|
||||
use itertools::Itertools;
|
||||
use std::convert::TryFrom;
|
||||
use std::fmt;
|
||||
use thiserror::Error;
|
||||
|
||||
#[derive(Error, Debug)]
|
||||
pub enum DiceRollingError {
|
||||
#[error("variable not found: {0}")]
|
||||
VariableNotFound(String),
|
||||
|
||||
#[error("dice pool expression too large")]
|
||||
ExpressionTooLarge,
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
|
||||
pub enum DicePoolQuality {
|
||||
|
|
@ -94,29 +82,6 @@ pub struct DicePool {
|
|||
pub(crate) modifiers: DicePoolModifiers,
|
||||
}
|
||||
|
||||
async fn calculate_dice_amount(pool: &DicePoolWithContext<'_>) -> Result<i32, BotError> {
|
||||
let stream = stream::iter(&pool.0.amounts);
|
||||
let key = UserAndRoom(&pool.1.username, &pool.1.room_id);
|
||||
let variables = &pool.1.db.variables.get_user_variables(&key)?;
|
||||
|
||||
use DiceRollingError::VariableNotFound;
|
||||
let dice_amount: Result<i32, BotError> = stream
|
||||
.then(|amount| async move {
|
||||
match &amount.element {
|
||||
Element::Number(num_dice) => Ok(*num_dice * amount.operator.mult()),
|
||||
Element::Variable(variable) => variables
|
||||
.get(variable)
|
||||
.ok_or(VariableNotFound(variable.clone().to_string()))
|
||||
.map(|i| *i)
|
||||
.map_err(|e| e.into()),
|
||||
}
|
||||
})
|
||||
.try_fold(0, |total, num_dice| async move { Ok(total + num_dice) })
|
||||
.await;
|
||||
|
||||
dice_amount
|
||||
}
|
||||
|
||||
impl DicePool {
|
||||
pub fn easy_pool(dice_amount: i32, quality: DicePoolQuality) -> DicePool {
|
||||
DicePool {
|
||||
|
|
@ -346,7 +311,7 @@ pub async fn roll_pool(pool: &DicePoolWithContext<'_>) -> Result<RolledDicePool,
|
|||
return Err(DiceRollingError::ExpressionTooLarge.into());
|
||||
}
|
||||
|
||||
let num_dice = calculate_dice_amount(&pool).await?;
|
||||
let num_dice = crate::dice::calculate_dice_amount(&pool.0.amounts, &pool.1).await?;
|
||||
let mut roller = RngDieRoller(rand::thread_rng());
|
||||
|
||||
if num_dice > 0 {
|
||||
|
|
@ -563,9 +528,13 @@ mod tests {
|
|||
}];
|
||||
|
||||
let pool = DicePool::new(amounts, DicePoolModifiers::default());
|
||||
let pool_with_ctx = DicePoolWithContext(&pool, &ctx);
|
||||
|
||||
assert_eq!(calculate_dice_amount(&pool_with_ctx).await.unwrap(), 10);
|
||||
assert_eq!(
|
||||
crate::dice::calculate_dice_amount(&pool.amounts, &ctx)
|
||||
.await
|
||||
.unwrap(),
|
||||
10
|
||||
);
|
||||
}
|
||||
|
||||
//DicePool tests
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
use super::{Command, Execution};
|
||||
use crate::context::Context;
|
||||
use crate::cthulhu::dice::{AdvancementRoll, DiceRoll};
|
||||
use crate::cthulhu::dice::{regular_roll, AdvancementRoll, DiceRoll, DiceRollWithContext};
|
||||
use async_trait::async_trait;
|
||||
|
||||
pub struct CthRoll(pub DiceRoll);
|
||||
|
|
@ -11,14 +11,25 @@ impl Command for CthRoll {
|
|||
"roll percentile pool"
|
||||
}
|
||||
|
||||
async fn execute(&self, _ctx: &Context<'_>) -> Execution {
|
||||
//TODO this will be converted to a result when supporting variables.
|
||||
let roll = self.0.roll();
|
||||
let plain = format!("Roll: {}\nResult: {}", self.0, roll);
|
||||
let html = format!(
|
||||
"<p><strong>Roll:</strong> {}</p><p><strong>Result</strong>: {}</p>",
|
||||
self.0, roll
|
||||
);
|
||||
async fn execute(&self, ctx: &Context<'_>) -> Execution {
|
||||
let roll_with_ctx = DiceRollWithContext(&self.0, ctx);
|
||||
let roll = regular_roll(&roll_with_ctx).await;
|
||||
|
||||
let (plain, html) = match roll {
|
||||
Ok(executed_roll) => {
|
||||
let plain = format!("Roll: {}\nResult: {}", executed_roll, executed_roll.roll);
|
||||
let html = format!(
|
||||
"<p><strong>Roll:</strong> {}</p><p><strong>Result</strong>: {}</p>",
|
||||
executed_roll, executed_roll.roll
|
||||
);
|
||||
(plain, html)
|
||||
}
|
||||
Err(e) => {
|
||||
let plain = format!("Error: {}", e);
|
||||
let html = format!("<p><strong>Error:</strong> {}</p>", e);
|
||||
(plain, html)
|
||||
}
|
||||
};
|
||||
|
||||
Execution { plain, html }
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,19 +1,17 @@
|
|||
use crate::context::Context;
|
||||
use crate::error::{BotError, DiceRollingError};
|
||||
use crate::parser::Amount;
|
||||
use std::convert::TryFrom;
|
||||
use std::fmt;
|
||||
|
||||
/// A planned dice roll.
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub struct DiceRoll {
|
||||
pub target: u32,
|
||||
pub amounts: Vec<Amount>,
|
||||
pub modifier: DiceRollModifier,
|
||||
}
|
||||
|
||||
impl fmt::Display for DiceRoll {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
let message = format!("target: {}, with {}", self.target, self.modifier);
|
||||
write!(f, "{}", message)?;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
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)]
|
||||
|
|
@ -91,6 +89,26 @@ impl fmt::Display for RollResult {
|
|||
}
|
||||
}
|
||||
|
||||
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(())
|
||||
}
|
||||
}
|
||||
|
||||
//TODO need to keep track of all rolled numbers for informational purposes!
|
||||
/// The outcome of a roll.
|
||||
pub struct RolledDice {
|
||||
|
|
@ -100,10 +118,6 @@ pub struct RolledDice {
|
|||
/// The number we must meet for the roll to be considered a
|
||||
/// success.
|
||||
target: u32,
|
||||
|
||||
/// Stored for informational purposes in display.
|
||||
#[allow(dead_code)]
|
||||
modifier: DiceRollModifier,
|
||||
}
|
||||
|
||||
impl RolledDice {
|
||||
|
|
@ -235,9 +249,14 @@ fn roll_percentile_dice<R: DieRoller>(roller: &mut R, unit_roll: u32) -> u32 {
|
|||
}
|
||||
}
|
||||
|
||||
fn roll_regular_dice<R: DieRoller>(roll: &DiceRoll, roller: &mut R) -> RolledDice {
|
||||
fn roll_regular_dice<R: DieRoller>(
|
||||
modifier: &DiceRollModifier,
|
||||
target: u32,
|
||||
roller: &mut R,
|
||||
) -> RolledDice {
|
||||
use DiceRollModifier::*;
|
||||
let num_rolls = match roll.modifier {
|
||||
|
||||
let num_rolls = match modifier {
|
||||
Normal => 1,
|
||||
OneBonus | OnePenalty => 2,
|
||||
TwoBonus | TwoPenalty => 3,
|
||||
|
|
@ -249,7 +268,7 @@ fn roll_regular_dice<R: DieRoller>(roll: &DiceRoll, roller: &mut R) -> RolledDic
|
|||
.map(|_| roll_percentile_dice(roller, unit_roll))
|
||||
.collect();
|
||||
|
||||
let num_rolled = match roll.modifier {
|
||||
let num_rolled = match modifier {
|
||||
Normal => rolls.first(),
|
||||
OneBonus | TwoBonus => rolls.iter().min(),
|
||||
OnePenalty | TwoPenalty => rolls.iter().max(),
|
||||
|
|
@ -257,9 +276,8 @@ fn roll_regular_dice<R: DieRoller>(roll: &DiceRoll, roller: &mut R) -> RolledDic
|
|||
.unwrap();
|
||||
|
||||
RolledDice {
|
||||
modifier: roll.modifier,
|
||||
num_rolled: *num_rolled,
|
||||
target: roll.target,
|
||||
target: target,
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -287,19 +305,29 @@ fn roll_advancement_dice<R: DieRoller>(
|
|||
}
|
||||
}
|
||||
|
||||
impl DiceRoll {
|
||||
/// 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 fn roll(&self) -> RolledDice {
|
||||
let mut roller = RngDieRoller(rand::thread_rng());
|
||||
roll_regular_dice(&self, &mut roller)
|
||||
}
|
||||
/// 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 =
|
||||
crate::dice::calculate_dice_amount(&roll_with_ctx.0.amounts, roll_with_ctx.1).await?;
|
||||
|
||||
let target = u32::try_from(target).map_err(|_| DiceRollingError::InvalidAmount)?;
|
||||
let mut roller = RngDieRoller(rand::thread_rng());
|
||||
let rolled_dice = roll_regular_dice(&roll_with_ctx.0.modifier, target, &mut roller);
|
||||
|
||||
Ok(ExecutedDiceRoll {
|
||||
target: target,
|
||||
modifier: roll_with_ctx.0.modifier,
|
||||
roll: rolled_dice,
|
||||
})
|
||||
}
|
||||
|
||||
impl AdvancementRoll {
|
||||
|
|
@ -312,6 +340,8 @@ impl AdvancementRoll {
|
|||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::db::Database;
|
||||
use crate::parser::{Amount, Element, Operator};
|
||||
|
||||
/// Generate a series of numbers manually for testing. For this
|
||||
/// die system, the first roll in the Vec should be the unit roll,
|
||||
|
|
@ -339,195 +369,141 @@ mod tests {
|
|||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn regular_roll_succeeds_when_below_target() {
|
||||
#[tokio::test]
|
||||
async fn regular_roll_converts_u32_safely() {
|
||||
let roll = DiceRoll {
|
||||
target: 50,
|
||||
amounts: vec![Amount {
|
||||
operator: Operator::Plus,
|
||||
element: Element::Number(-10),
|
||||
}],
|
||||
modifier: DiceRollModifier::Normal,
|
||||
};
|
||||
|
||||
let db = Database::new_temp().unwrap();
|
||||
let ctx = Context::new(&db, "roomid", "username", "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))
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn regular_roll_succeeds_when_below_target() {
|
||||
//Roll 30, succeeding.
|
||||
let mut roller = SequentialDieRoller::new(vec![0, 3]);
|
||||
let rolled = roll_regular_dice(&roll, &mut roller);
|
||||
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() {
|
||||
let roll = DiceRoll {
|
||||
target: 50,
|
||||
modifier: DiceRollModifier::Normal,
|
||||
};
|
||||
|
||||
//Roll 25, succeeding.
|
||||
let mut roller = SequentialDieRoller::new(vec![5, 2]);
|
||||
let rolled = roll_regular_dice(&roll, &mut roller);
|
||||
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() {
|
||||
let roll = DiceRoll {
|
||||
target: 50,
|
||||
modifier: DiceRollModifier::Normal,
|
||||
};
|
||||
|
||||
//Roll 10, succeeding extremely.
|
||||
let mut roller = SequentialDieRoller::new(vec![0, 1]);
|
||||
let rolled = roll_regular_dice(&roll, &mut roller);
|
||||
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() {
|
||||
let roll = DiceRoll {
|
||||
target: 150,
|
||||
modifier: DiceRollModifier::Normal,
|
||||
};
|
||||
|
||||
//Roll 30, succeeding extremely.
|
||||
let mut roller = SequentialDieRoller::new(vec![0, 3]);
|
||||
let rolled = roll_regular_dice(&roll, &mut roller);
|
||||
let rolled = roll_regular_dice(&DiceRollModifier::Normal, 150, &mut roller);
|
||||
assert_eq!(RollResult::ExtremeSuccess, rolled.result());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn regular_roll_critical_success_on_one() {
|
||||
let roll = DiceRoll {
|
||||
target: 50,
|
||||
modifier: DiceRollModifier::Normal,
|
||||
};
|
||||
|
||||
//Roll 1.
|
||||
let mut roller = SequentialDieRoller::new(vec![1, 0]);
|
||||
let rolled = roll_regular_dice(&roll, &mut roller);
|
||||
let rolled = roll_regular_dice(&DiceRollModifier::Normal, 50, &mut roller);
|
||||
assert_eq!(RollResult::CriticalSuccess, rolled.result());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn regular_roll_fail_when_above_target() {
|
||||
let roll = DiceRoll {
|
||||
target: 50,
|
||||
modifier: DiceRollModifier::Normal,
|
||||
};
|
||||
|
||||
//Roll 60.
|
||||
let mut roller = SequentialDieRoller::new(vec![0, 6]);
|
||||
let rolled = roll_regular_dice(&roll, &mut roller);
|
||||
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() {
|
||||
let roll = DiceRoll {
|
||||
target: 49,
|
||||
modifier: DiceRollModifier::Normal,
|
||||
};
|
||||
|
||||
//Roll 96.
|
||||
let mut roller = SequentialDieRoller::new(vec![6, 9]);
|
||||
let rolled = roll_regular_dice(&roll, &mut roller);
|
||||
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() {
|
||||
let roll = DiceRoll {
|
||||
target: 50,
|
||||
modifier: DiceRollModifier::Normal,
|
||||
};
|
||||
|
||||
//Roll 96.
|
||||
let mut roller = SequentialDieRoller::new(vec![6, 9]);
|
||||
let rolled = roll_regular_dice(&roll, &mut roller);
|
||||
let rolled = roll_regular_dice(&DiceRollModifier::Normal, 50, &mut roller);
|
||||
assert_eq!(RollResult::Failure, rolled.result());
|
||||
|
||||
let roll = DiceRoll {
|
||||
target: 68,
|
||||
modifier: DiceRollModifier::Normal,
|
||||
};
|
||||
|
||||
//Roll 96.
|
||||
let mut roller = SequentialDieRoller::new(vec![6, 9]);
|
||||
let rolled = roll_regular_dice(&roll, &mut roller);
|
||||
let rolled = roll_regular_dice(&DiceRollModifier::Normal, 68, &mut roller);
|
||||
assert_eq!(RollResult::Failure, rolled.result());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn regular_roll_always_fumble_on_100() {
|
||||
let roll = DiceRoll {
|
||||
target: 100,
|
||||
modifier: DiceRollModifier::Normal,
|
||||
};
|
||||
|
||||
//Roll 100.
|
||||
let mut roller = SequentialDieRoller::new(vec![0, 0]);
|
||||
let rolled = roll_regular_dice(&roll, &mut roller);
|
||||
let rolled = roll_regular_dice(&DiceRollModifier::Normal, 100, &mut roller);
|
||||
assert_eq!(RollResult::Fumble, rolled.result());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn one_penalty_picks_highest_of_two() {
|
||||
let roll = DiceRoll {
|
||||
target: 50,
|
||||
modifier: DiceRollModifier::OnePenalty,
|
||||
};
|
||||
|
||||
//Should only roll 30 and 40, not 50.
|
||||
let mut roller = SequentialDieRoller::new(vec![0, 3, 4, 5]);
|
||||
let rolled = roll_regular_dice(&roll, &mut roller);
|
||||
let rolled = roll_regular_dice(&DiceRollModifier::OnePenalty, 50, &mut roller);
|
||||
assert_eq!(40, rolled.num_rolled);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn two_penalty_picks_highest_of_three() {
|
||||
let roll = DiceRoll {
|
||||
target: 50,
|
||||
modifier: DiceRollModifier::TwoPenalty,
|
||||
};
|
||||
|
||||
//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(&roll, &mut roller);
|
||||
let rolled = roll_regular_dice(&DiceRollModifier::TwoPenalty, 50, &mut roller);
|
||||
assert_eq!(50, rolled.num_rolled);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn one_bonus_picks_lowest_of_two() {
|
||||
let roll = DiceRoll {
|
||||
target: 50,
|
||||
modifier: DiceRollModifier::OneBonus,
|
||||
};
|
||||
|
||||
//Should only roll 30 and 40, not 20.
|
||||
let mut roller = SequentialDieRoller::new(vec![0, 3, 4, 2]);
|
||||
let rolled = roll_regular_dice(&roll, &mut roller);
|
||||
let rolled = roll_regular_dice(&DiceRollModifier::OneBonus, 50, &mut roller);
|
||||
assert_eq!(30, rolled.num_rolled);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn two_bonus_picks_lowest_of_three() {
|
||||
let roll = DiceRoll {
|
||||
target: 50,
|
||||
modifier: DiceRollModifier::TwoBonus,
|
||||
};
|
||||
|
||||
//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(&roll, &mut roller);
|
||||
let rolled = roll_regular_dice(&DiceRollModifier::TwoBonus, 50, &mut roller);
|
||||
assert_eq!(30, rolled.num_rolled);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn normal_modifier_rolls_once() {
|
||||
let roll = DiceRoll {
|
||||
target: 50,
|
||||
modifier: DiceRollModifier::Normal,
|
||||
};
|
||||
|
||||
//Should only roll 30, not 40.
|
||||
let mut roller = SequentialDieRoller::new(vec![0, 3, 4]);
|
||||
let rolled = roll_regular_dice(&roll, &mut roller);
|
||||
let rolled = roll_regular_dice(&DiceRollModifier::Normal, 50, &mut roller);
|
||||
assert_eq!(30, rolled.num_rolled);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -3,33 +3,40 @@ use crate::parser::DiceParsingError;
|
|||
|
||||
//TOOD convert these to use parse_amounts from the common dice code.
|
||||
|
||||
fn parse_modifier(input: &str) -> Result<(DiceRollModifier, &str), DiceParsingError> {
|
||||
fn parse_modifier(input: &str) -> Result<DiceRollModifier, DiceParsingError> {
|
||||
if input.ends_with("bb") {
|
||||
Ok((DiceRollModifier::TwoBonus, input.trim_end_matches("bb")))
|
||||
Ok(DiceRollModifier::TwoBonus)
|
||||
} else if input.ends_with("b") {
|
||||
Ok((DiceRollModifier::OneBonus, input.trim_end_matches("b")))
|
||||
Ok(DiceRollModifier::OneBonus)
|
||||
} else if input.ends_with("pp") {
|
||||
Ok((DiceRollModifier::TwoPenalty, input.trim_end_matches("pp")))
|
||||
Ok(DiceRollModifier::TwoPenalty)
|
||||
} else if input.ends_with("p") {
|
||||
Ok((DiceRollModifier::OnePenalty, input.trim_end_matches("p")))
|
||||
Ok(DiceRollModifier::OnePenalty)
|
||||
} else {
|
||||
Ok((DiceRollModifier::Normal, input))
|
||||
Ok(DiceRollModifier::Normal)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn parse_regular_roll(input: &str) -> Result<DiceRoll, DiceParsingError> {
|
||||
let input = input.trim();
|
||||
let (modifier, input) = parse_modifier(input)?;
|
||||
let target: u32 = input.parse().map_err(|_| DiceParsingError::InvalidAmount)?;
|
||||
//Make diceroll take a vec of Amounts
|
||||
//Split based on :, send first part to parse_modifier.
|
||||
//Send second part to parse_amounts
|
||||
|
||||
if target <= 100 {
|
||||
Ok(DiceRoll {
|
||||
target: target,
|
||||
modifier: modifier,
|
||||
})
|
||||
} else {
|
||||
Err(DiceParsingError::InvalidAmount)
|
||||
}
|
||||
pub fn parse_regular_roll(input: &str) -> Result<DiceRoll, DiceParsingError> {
|
||||
let input: Vec<&str> = input.trim().split(":").collect();
|
||||
|
||||
let (modifiers_str, amounts_str) = match input[..] {
|
||||
[amounts] => Ok(("", amounts)),
|
||||
[modifiers, amounts] => Ok((modifiers, amounts)),
|
||||
_ => Err(DiceParsingError::UnconsumedInput),
|
||||
}?;
|
||||
|
||||
let modifier = parse_modifier(modifiers_str)?;
|
||||
let amounts = crate::parser::parse_amounts(amounts_str)?;
|
||||
|
||||
Ok(DiceRoll {
|
||||
amounts: amounts,
|
||||
modifier: modifier,
|
||||
})
|
||||
}
|
||||
|
||||
pub fn parse_advancement_roll(input: &str) -> Result<AdvancementRoll, DiceParsingError> {
|
||||
|
|
@ -49,6 +56,7 @@ pub fn parse_advancement_roll(input: &str) -> Result<AdvancementRoll, DiceParsin
|
|||
mod tests {
|
||||
|
||||
use super::*;
|
||||
use crate::parser::{Amount, Element, Operator};
|
||||
|
||||
#[test]
|
||||
fn regular_roll_accepts_single_number() {
|
||||
|
|
@ -56,7 +64,10 @@ mod tests {
|
|||
assert!(result.is_ok());
|
||||
assert_eq!(
|
||||
DiceRoll {
|
||||
target: 60,
|
||||
amounts: vec![Amount {
|
||||
operator: Operator::Plus,
|
||||
element: Element::Number(60)
|
||||
}],
|
||||
modifier: DiceRollModifier::Normal
|
||||
},
|
||||
result.unwrap()
|
||||
|
|
@ -65,11 +76,14 @@ mod tests {
|
|||
|
||||
#[test]
|
||||
fn regular_roll_accepts_two_bonus() {
|
||||
let result = parse_regular_roll("60bb");
|
||||
let result = parse_regular_roll("bb:60");
|
||||
assert!(result.is_ok());
|
||||
assert_eq!(
|
||||
DiceRoll {
|
||||
target: 60,
|
||||
amounts: vec![Amount {
|
||||
operator: Operator::Plus,
|
||||
element: Element::Number(60)
|
||||
}],
|
||||
modifier: DiceRollModifier::TwoBonus
|
||||
},
|
||||
result.unwrap()
|
||||
|
|
@ -78,11 +92,14 @@ mod tests {
|
|||
|
||||
#[test]
|
||||
fn regular_roll_accepts_one_bonus() {
|
||||
let result = parse_regular_roll("60b");
|
||||
let result = parse_regular_roll("b:60");
|
||||
assert!(result.is_ok());
|
||||
assert_eq!(
|
||||
DiceRoll {
|
||||
target: 60,
|
||||
amounts: vec![Amount {
|
||||
operator: Operator::Plus,
|
||||
element: Element::Number(60)
|
||||
}],
|
||||
modifier: DiceRollModifier::OneBonus
|
||||
},
|
||||
result.unwrap()
|
||||
|
|
@ -91,11 +108,14 @@ mod tests {
|
|||
|
||||
#[test]
|
||||
fn regular_roll_accepts_two_penalty() {
|
||||
let result = parse_regular_roll("60pp");
|
||||
let result = parse_regular_roll("pp:60");
|
||||
assert!(result.is_ok());
|
||||
assert_eq!(
|
||||
DiceRoll {
|
||||
target: 60,
|
||||
amounts: vec![Amount {
|
||||
operator: Operator::Plus,
|
||||
element: Element::Number(60)
|
||||
}],
|
||||
modifier: DiceRollModifier::TwoPenalty
|
||||
},
|
||||
result.unwrap()
|
||||
|
|
@ -104,11 +124,14 @@ mod tests {
|
|||
|
||||
#[test]
|
||||
fn regular_roll_accepts_one_penalty() {
|
||||
let result = parse_regular_roll("60p");
|
||||
let result = parse_regular_roll("p:60");
|
||||
assert!(result.is_ok());
|
||||
assert_eq!(
|
||||
DiceRoll {
|
||||
target: 60,
|
||||
amounts: vec![Amount {
|
||||
operator: Operator::Plus,
|
||||
element: Element::Number(60)
|
||||
}],
|
||||
modifier: DiceRollModifier::OnePenalty
|
||||
},
|
||||
result.unwrap()
|
||||
|
|
@ -121,21 +144,21 @@ mod tests {
|
|||
assert!(parse_regular_roll(" 60").is_ok());
|
||||
assert!(parse_regular_roll(" 60 ").is_ok());
|
||||
|
||||
assert!(parse_regular_roll("60bb ").is_ok());
|
||||
assert!(parse_regular_roll(" 60bb").is_ok());
|
||||
assert!(parse_regular_roll(" 60bb ").is_ok());
|
||||
assert!(parse_regular_roll("bb:60 ").is_ok());
|
||||
assert!(parse_regular_roll(" bb:60").is_ok());
|
||||
assert!(parse_regular_roll(" bb:60 ").is_ok());
|
||||
|
||||
assert!(parse_regular_roll("60b ").is_ok());
|
||||
assert!(parse_regular_roll(" 60b").is_ok());
|
||||
assert!(parse_regular_roll(" 60b ").is_ok());
|
||||
assert!(parse_regular_roll("b:60 ").is_ok());
|
||||
assert!(parse_regular_roll(" b:60").is_ok());
|
||||
assert!(parse_regular_roll(" b:60 ").is_ok());
|
||||
|
||||
assert!(parse_regular_roll("60pp ").is_ok());
|
||||
assert!(parse_regular_roll(" 60pp").is_ok());
|
||||
assert!(parse_regular_roll(" 60pp ").is_ok());
|
||||
assert!(parse_regular_roll("pp:60 ").is_ok());
|
||||
assert!(parse_regular_roll(" pp:60").is_ok());
|
||||
assert!(parse_regular_roll(" pp:60 ").is_ok());
|
||||
|
||||
assert!(parse_regular_roll("60p ").is_ok());
|
||||
assert!(parse_regular_roll(" 60p").is_ok());
|
||||
assert!(parse_regular_roll(" 60p ").is_ok());
|
||||
assert!(parse_regular_roll("p:60 ").is_ok());
|
||||
assert!(parse_regular_roll(" p:60").is_ok());
|
||||
assert!(parse_regular_roll(" p:60 ").is_ok());
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -152,21 +175,11 @@ mod tests {
|
|||
assert_eq!(AdvancementRoll { existing_skill: 60 }, result.unwrap());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn regular_roll_rejects_big_numbers() {
|
||||
assert!(parse_regular_roll("3000").is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn advancement_roll_rejects_big_numbers() {
|
||||
assert!(parse_advancement_roll("3000").is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn regular_roll_rejects_invalid_input() {
|
||||
assert!(parse_regular_roll("abc").is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn advancement_roll_rejects_invalid_input() {
|
||||
assert!(parse_advancement_roll("abc").is_err());
|
||||
|
|
|
|||
33
src/dice.rs
33
src/dice.rs
|
|
@ -1,8 +1,41 @@
|
|||
pub mod parser;
|
||||
|
||||
use crate::context::Context;
|
||||
use crate::db::variables::UserAndRoom;
|
||||
use crate::error::BotError;
|
||||
use crate::error::DiceRollingError;
|
||||
use crate::parser::Amount;
|
||||
use crate::parser::Element as NewElement;
|
||||
use futures::stream::{self, StreamExt, TryStreamExt};
|
||||
use std::fmt;
|
||||
use std::ops::{Deref, DerefMut};
|
||||
|
||||
//New hotness
|
||||
pub async fn calculate_dice_amount(amounts: &[Amount], ctx: &Context<'_>) -> Result<i32, BotError> {
|
||||
let stream = stream::iter(amounts);
|
||||
let key = UserAndRoom(&ctx.username, &ctx.room_id);
|
||||
let variables = &ctx.db.variables.get_user_variables(&key)?;
|
||||
|
||||
use DiceRollingError::VariableNotFound;
|
||||
let dice_amount: Result<i32, BotError> = stream
|
||||
.then(|amount| async move {
|
||||
match &amount.element {
|
||||
NewElement::Number(num_dice) => Ok(*num_dice * amount.operator.mult()),
|
||||
NewElement::Variable(variable) => variables
|
||||
.get(variable)
|
||||
.ok_or(VariableNotFound(variable.clone().to_string()))
|
||||
.map(|i| *i)
|
||||
.map_err(|e| e.into()),
|
||||
}
|
||||
})
|
||||
.try_fold(0, |total, num_dice| async move { Ok(total + num_dice) })
|
||||
.await;
|
||||
|
||||
dice_amount
|
||||
}
|
||||
|
||||
//Old stuff, for regular dice rolling. To be moved elsewhere.
|
||||
|
||||
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
|
||||
pub struct Dice {
|
||||
pub(crate) count: u32,
|
||||
|
|
|
|||
15
src/error.rs
15
src/error.rs
|
|
@ -1,4 +1,3 @@
|
|||
use crate::cofd::dice::DiceRollingError;
|
||||
use crate::commands::CommandError;
|
||||
use crate::config::ConfigError;
|
||||
use crate::db::errors::DataError;
|
||||
|
|
@ -50,7 +49,7 @@ pub enum BotError {
|
|||
#[error("command parsing error: {0}")]
|
||||
CommandParsingError(#[from] crate::commands::parser::CommandParsingError),
|
||||
|
||||
#[error("dice pool roll error: {0}")]
|
||||
#[error("dice rolling error: {0}")]
|
||||
DiceRollingError(#[from] DiceRollingError),
|
||||
|
||||
#[error("variable parsing error: {0}")]
|
||||
|
|
@ -68,3 +67,15 @@ pub enum BotError {
|
|||
#[error("database error")]
|
||||
DatabaseErrror(#[from] sled::Error),
|
||||
}
|
||||
|
||||
#[derive(Error, Debug)]
|
||||
pub enum DiceRollingError {
|
||||
#[error("variable not found: {0}")]
|
||||
VariableNotFound(String),
|
||||
|
||||
#[error("invalid amount")]
|
||||
InvalidAmount,
|
||||
|
||||
#[error("dice pool expression too large")]
|
||||
ExpressionTooLarge,
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue