adne/Rollux
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Code cleanup

Browse Source
This commit is contained in:
Ådne E. Moldesæter 2020-08-27 20:49:06 +02:00
parent 6a1f5b6035
commit 56a37a738f
2 changed files with 433 additions and 270 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

141
src/lib.rs
View File

@ -1,15 +1,18 @@
use anyhow::Result;
use rand::seq::SliceRandom;
use rand::Rng;
use regex::Regex;
use thiserror::Error;
use anyhow::Result;
use rand::Rng;
use rand::seq::SliceRandom;
#[cfg(test)]
mod lib_test;
#[derive(Debug, PartialEq, Clone)]
enum DiceFilter {
DropLowest(usize), DropHighest(usize), KeepLowest(usize), KeepHighest(usize),
DropLowest(usize),
DropHighest(usize),
KeepLowest(usize),
KeepHighest(usize),
}
#[derive(Debug, PartialEq, Clone)]
@ -42,36 +45,58 @@ fn construct_dice_filter(op: &str, amount: usize) -> Result<DiceFilter> {
"dh" => Ok(DiceFilter::DropHighest(amount)),
"k" | "kh" => Ok(DiceFilter::KeepHighest(amount)),
"kl" => Ok(DiceFilter::KeepLowest(amount)),
_ => Err(SegmentError::InvalidFilterOperator{op: op.to_owned()})?,
_ => Err(SegmentError::InvalidFilterOperator { op: op.to_owned() }.into()),
}
}
fn construct_dice_segment(cap: regex::Captures<'_>) -> Result<Segment> {
let op = cap.name("op").and_then(|i| i.as_str().chars().next()).unwrap_or('+');
let op = cap
.name("op")
.and_then(|i| i.as_str().chars().next())
.unwrap_or('+');
let modifier = cap.name("mod").map(|i| i.as_str().parse()).transpose()?;
if let Some(amount) = modifier {
return Ok(Segment::Modifier { op, amount });
}
let count:i32 = cap.name("count").map(|i| i.as_str().parse()).transpose()?.unwrap_or(1);
let size:i32 = cap.name("size").map(|i| i.as_str().parse()).transpose()?.ok_or(SegmentError::SizeIsMissing)?;
let filter_amount = cap.name("filter").map(|i| i.as_str().parse::<usize>()).transpose()?;
let count: i32 = cap
.name("count")
.map(|i| i.as_str().parse())
.transpose()?
.unwrap_or(1);
let size: i32 = cap
.name("size")
.map(|i| i.as_str().parse())
.transpose()?
.ok_or(SegmentError::SizeIsMissing)?;
let filter_amount = cap
.name("filter")
.map(|i| i.as_str().parse::<usize>())
.transpose()?;
let filter_op = cap.name("filter_op").map(|op| op.as_str());
/*
dbg!(filter_amount);
dbg!(filter_op);
*/
if filter_amount.is_some() != filter_op.is_some() {
Err(SegmentError::IncompleteFilter)?;
return Err(SegmentError::IncompleteFilter.into());
}
let filter = filter_amount.and_then(|amount| (filter_op.map(|op| construct_dice_filter(op, amount)))).transpose()?;
let filter = filter_amount
.and_then(|amount| (filter_op.map(|op| construct_dice_filter(op, amount))))
.transpose()?;
Ok(Segment::DiceRoll{op, count, size, filter})
Ok(Segment::DiceRoll {
op,
count,
size,
filter,
})
}
fn parse_dice_segments(cmd: &str) -> Result<Vec<Segment>> {
let regex = Regex::new(r#"(?x)
let regex = Regex::new(
r#"(?x)
(?P<op>[+\-/*])?
\s*
(?:
@ -85,15 +110,20 @@ fn parse_dice_segments(cmd: &str) -> Result<Vec<Segment>> {
(?P<mod>\d+)
)
)
"#).expect("Failed to compile regex");
"#,
)
.expect("Failed to compile regex");
regex.captures_iter(cmd).map(construct_dice_segment).collect()
regex
.captures_iter(cmd)
.map(construct_dice_segment)
.collect()
}
#[derive(Debug, PartialEq, Clone)]
struct RollWithModifier {
diceroll: Option<Segment>,
modifiers: Vec<Segment>
modifiers: Vec<Segment>,
}
fn group_modifiers_to_dicerolls(segments: &[Segment]) -> Vec<RollWithModifier> {
@ -104,7 +134,7 @@ fn group_modifiers_to_dicerolls(segments: &[Segment]) -> Vec<RollWithModifier> {
for segment in segments {
if let Segment::DiceRoll { .. } = segment {
if current_diceroll.is_some() || current_modifiers.len() > 0 {
if current_diceroll.is_some() || !current_modifiers.is_empty() {
let with_modifier = RollWithModifier {
diceroll: current_diceroll.clone(),
modifiers: current_modifiers.clone(),
@ -116,15 +146,14 @@ fn group_modifiers_to_dicerolls(segments: &[Segment]) -> Vec<RollWithModifier> {
}
current_diceroll = Some(segment.clone());
}
else if let Segment::Modifier { .. } = segment {
} else if let Segment::Modifier { .. } = segment {
current_modifiers.push(segment.clone());
}
}
if current_diceroll.is_some() || current_modifiers.len() > 0 {
if current_diceroll.is_some() || !current_modifiers.is_empty() {
let with_modifier = RollWithModifier {
diceroll: current_diceroll.clone(),
diceroll: current_diceroll,
modifiers: current_modifiers.clone(),
};
@ -153,7 +182,10 @@ enum RollError {
InvalidOperator(char),
}
fn roll_dice_segments<R: Rng>(rwms: &[RollWithModifier], mut rng: R) -> Result<Vec<Roll>, RollError> {
fn roll_dice_segments<R: Rng>(
rwms: &[RollWithModifier],
mut rng: R,
) -> Result<Vec<Roll>, RollError> {
rwms.iter()
.map(|rwm| {
let mut results = Vec::new();
@ -168,28 +200,32 @@ fn roll_dice_segments<R: Rng>(rwms: &[RollWithModifier], mut rng: R) -> Result<V
return Err(RollError::EmptyRollWithModifier);
};
if let Some(Segment::DiceRoll{count, size, filter, ..}) = &rwm.diceroll {
results = (0..*count).map(|_| {
rng.gen_range(1, size + 1)
}).collect();
if let Some(Segment::DiceRoll {
count,
size,
filter,
..
}) = &rwm.diceroll
{
results = (0..*count).map(|_| rng.gen_range(1, size + 1)).collect();
results.sort();
if let Some(filter) = filter {
match filter {
DiceFilter::DropLowest(n) => {
results = results.into_iter().skip(*n).collect();
},
}
DiceFilter::DropHighest(n) => {
let len = results.len();
results = results.into_iter().take(len - n).collect();
},
}
DiceFilter::KeepLowest(n) => {
results = results.into_iter().take(*n).collect();
},
}
DiceFilter::KeepHighest(n) => {
let len = results.len();
results = results.into_iter().skip(len - n).collect();
},
}
}
}
results.shuffle(&mut rng);
@ -200,23 +236,41 @@ fn roll_dice_segments<R: Rng>(rwms: &[RollWithModifier], mut rng: R) -> Result<V
for segment in &rwm.modifiers {
if let Segment::Modifier { op, amount } = segment {
match op {
'+' => { total += amount; },
'-' => { total -= amount; },
'/' => { total /= amount; },
'*' => { total *= amount; },
'+' => {
total += amount;
}
'-' => {
total -= amount;
}
'/' => {
total /= amount;
}
'*' => {
total *= amount;
}
_ => {
return Err(RollError::InvalidFilterOperator(*op));
},
}
}
}
}
Ok(Roll{operator, results, total})
Ok(Roll {
operator,
results,
total,
})
})
.collect::<Result<Vec<_>, _>>()
}
fn roll_dice<R : Rng>(s: &str, mut rng: R) -> Result<(i32, Vec<(Roll, Vec<Segment>)>)> {
#[derive(Debug, PartialEq, Clone)]
struct RollSet {
total: i32,
rolls: Vec<(Roll, Vec<Segment>)>,
}
fn roll_dice<R: Rng>(s: &str, mut rng: R) -> Result<RollSet> {
let segments = parse_dice_segments(s)?;
let groups = group_modifiers_to_dicerolls(&segments);
@ -228,11 +282,16 @@ fn roll_dice<R : Rng>(s: &str, mut rng: R) -> Result<(i32, Vec<(Roll, Vec<Segmen
'-' => Ok(acc - roll.total),
'*' => Ok(acc * roll.total),
'/' => Ok(acc / roll.total),
_ => Err(RollError::InvalidOperator(roll.operator))
_ => Err(RollError::InvalidOperator(roll.operator)),
})?;
let rolls_with_modifiers = rolls.into_iter()
.zip(groups.into_iter().map(|grp| grp.modifiers)).collect();
let rolls_with_modifiers = rolls
.into_iter()
.zip(groups.into_iter().map(|grp| grp.modifiers))
.collect();
Ok((total, rolls_with_modifiers))
Ok(RollSet {
total,
rolls: rolls_with_modifiers,
})
}

194
src/lib_test.rs
View File

@ -1,63 +1,125 @@
use rand::{rngs::StdRng, SeedableRng};
use super::*;
use rand::{rngs::StdRng, SeedableRng};
#[test]
fn test_parse_dice_segments() {
let mut results = parse_dice_segments("2d6").expect("Failed to unpack results");
assert_eq!(results, vec![ Segment::DiceRoll{ op: '+', count: 2, size: 6, filter: None } ]);
assert_eq!(
results,
vec![Segment::DiceRoll {
op: '+',
count: 2,
size: 6,
filter: None
}]
);
results = parse_dice_segments("2d6 + 1d20").expect("Failed to unpack results");
assert_eq!(results, vec![
Segment::DiceRoll{ op: '+', count: 2, size: 6, filter: None },
Segment::DiceRoll{ op: '+', count: 1, size: 20, filter: None },
]);
assert_eq!(
results,
vec![
Segment::DiceRoll {
op: '+',
count: 2,
size: 6,
filter: None
},
Segment::DiceRoll {
op: '+',
count: 1,
size: 20,
filter: None
},
]
);
results = parse_dice_segments("4d6d1").expect("Failed to unpack results");
assert_eq!(results, vec![
Segment::DiceRoll{ op: '+', count: 4, size: 6, filter: Some(DiceFilter::DropLowest(1)) },
]);
assert_eq!(
results,
vec![Segment::DiceRoll {
op: '+',
count: 4,
size: 6,
filter: Some(DiceFilter::DropLowest(1))
},]
);
results = parse_dice_segments("3d8+8").expect("Failed to unpack results");
assert_eq!(results, vec![
Segment::DiceRoll{ op: '+', count: 3, size: 8, filter: None },
assert_eq!(
results,
vec![
Segment::DiceRoll {
op: '+',
count: 3,
size: 8,
filter: None
},
Segment::Modifier { op: '+', amount: 8 },
]);
]
);
results = parse_dice_segments("3d8kl3 - 2d1dh1 / 2").expect("Failed to unpack results");
assert_eq!(results, vec![
Segment::DiceRoll{ op: '+', count: 3, size: 8, filter: Some(DiceFilter::KeepLowest(3)) },
Segment::DiceRoll{ op: '-', count: 2, size: 1, filter: Some(DiceFilter::DropHighest(1)) },
assert_eq!(
results,
vec![
Segment::DiceRoll {
op: '+',
count: 3,
size: 8,
filter: Some(DiceFilter::KeepLowest(3))
},
Segment::DiceRoll {
op: '-',
count: 2,
size: 1,
filter: Some(DiceFilter::DropHighest(1))
},
Segment::Modifier { op: '/', amount: 2 },
]);
]
);
}
#[test]
fn test_group_modifiers_to_dicerolls() {
let segments = parse_dice_segments("2d20 / 2 + 2 + 4d6 * 2 * 2").expect("Failed to unpack results");
let segments =
parse_dice_segments("2d20 / 2 + 2 + 4d6 * 2 * 2").expect("Failed to unpack results");
let results = group_modifiers_to_dicerolls(&segments);
assert_eq!(results, vec![
assert_eq!(
results,
vec![
RollWithModifier {
diceroll: Some(Segment::DiceRoll{ op: '+', count: 2, size: 20, filter: None }),
diceroll: Some(Segment::DiceRoll {
op: '+',
count: 2,
size: 20,
filter: None
}),
modifiers: vec![
Segment::Modifier { op: '/', amount: 2 },
Segment::Modifier { op: '+', amount: 2 },
]
},
RollWithModifier {
diceroll: Some(Segment::DiceRoll{ op: '+', count: 4, size: 6, filter: None }),
diceroll: Some(Segment::DiceRoll {
op: '+',
count: 4,
size: 6,
filter: None
}),
modifiers: vec![
Segment::Modifier { op: '*', amount: 2 },
Segment::Modifier { op: '*', amount: 2 },
]
},
]);
]
);
}
#[test]
@ -66,15 +128,16 @@ fn test_group_modifiers_to_dicerolls_no_diceroll() {
let results = group_modifiers_to_dicerolls(&segments);
assert_eq!(results, vec![
RollWithModifier{
assert_eq!(
results,
vec![RollWithModifier {
diceroll: None,
modifiers: vec![
Segment::Modifier { op: '*', amount: 2 },
Segment::Modifier { op: '*', amount: 2 },
]
},
]);
},]
);
}
#[test]
@ -85,61 +148,102 @@ fn test_roll_dice_segments() {
let rolls_with_modifiers = group_modifiers_to_dicerolls(&segments);
let results = roll_dice_segments(&rolls_with_modifiers, &mut rng);
assert_eq!(results, Ok(vec![Roll{operator: '+', results: vec![4, 5, 5, 1], total: 15}]));
assert_eq!(
results,
Ok(vec![Roll {
operator: '+',
results: vec![4, 5, 5, 1],
total: 15
}])
);
let segments = parse_dice_segments("4d6d1 + 2").expect("Failed to unpack results");
let rolls_with_modifiers = group_modifiers_to_dicerolls(&segments);
let results = roll_dice_segments(&rolls_with_modifiers, &mut rng);
assert_eq!(results, Ok(vec![Roll{operator: '+', results: vec![1, 1, 5], total: 9}]));
assert_eq!(
results,
Ok(vec![Roll {
operator: '+',
results: vec![1, 1, 5],
total: 9
}])
);
let segments = parse_dice_segments("+ 2 + 2d12kh1 / 2").expect("Failed to unpack results");
let rolls_with_modifiers = group_modifiers_to_dicerolls(&segments);
let results = roll_dice_segments(&rolls_with_modifiers, &mut rng);
assert_eq!(results, Ok(vec![
Roll{operator: '+', results: vec![], total: 2},
Roll{operator: '+', results: vec![12], total: 6},
]));
assert_eq!(
results,
Ok(vec![
Roll {
operator: '+',
results: vec![],
total: 2
},
Roll {
operator: '+',
results: vec![12],
total: 6
},
])
);
let segments = parse_dice_segments("1d6 * 1d6 + 2 / 2").expect("Failed to unpack results");
let rolls_with_modifiers = group_modifiers_to_dicerolls(&segments);
let results = roll_dice_segments(&rolls_with_modifiers, &mut rng);
assert_eq!(results, Ok(vec![
Roll{operator: '+', results: vec![1], total: 1},
Roll{operator: '*', results: vec![6], total: 4},
]));
assert_eq!(
results,
Ok(vec![
Roll {
operator: '+',
results: vec![1],
total: 1
},
Roll {
operator: '*',
results: vec![6],
total: 4
},
])
);
}
#[test]
fn test_roll_dice() {
let input = "4d6d2 + 2 - 1d4";
let mut rng = StdRng::seed_from_u64(2);
let result = roll_dice(input, &mut rng);
let expected = (8i32, vec![
(Roll {
let expected = RollSet {
total: 8i32,
rolls: vec![
(
Roll {
operator: '+',
results: vec![5, 5],
total: 12
total: 12,
},
vec![Segment::Modifier { op: '+', amount: 2 }]),
(Roll {
vec![Segment::Modifier { op: '+', amount: 2 }],
),
(
Roll {
operator: '-',
results: vec![4],
total: 4
total: 4,
},
vec![])]);
vec![],
),
],
};
if let Ok(result) = result {
assert_eq!(result, expected);
} else {
panic!("Expected Ok, was: {:?}", result);
}
}