946 lines
34 KiB
Rust
946 lines
34 KiB
Rust
pub mod changes;
|
|
mod process;
|
|
|
|
use core::num::NonZeroU8;
|
|
use std::collections::VecDeque;
|
|
|
|
use serde::{Deserialize, Serialize};
|
|
use werewolves_macros::Extract;
|
|
|
|
use super::Result;
|
|
use crate::{
|
|
character::{Character, CharacterId},
|
|
diedto::DiedTo,
|
|
error::GameError,
|
|
game::{
|
|
GameTime, Village,
|
|
kill::{self},
|
|
night::changes::{ChangesLookup, NightChange},
|
|
story::NightChoice,
|
|
},
|
|
message::night::{ActionPrompt, ActionResponse, ActionResult, Visits},
|
|
player::Protection,
|
|
role::{PYREMASTER_VILLAGER_KILLS_TO_DIE, RoleBlock, RoleTitle},
|
|
};
|
|
|
|
enum BlockResolvedOutcome {
|
|
PromptUpdate(ActionPrompt),
|
|
ActionComplete(ActionResult, Option<NightChange>),
|
|
}
|
|
|
|
enum ResponseOutcome {
|
|
PromptUpdate(ActionPrompt),
|
|
ActionComplete(ActionComplete),
|
|
}
|
|
|
|
struct ActionComplete {
|
|
pub result: ActionResult,
|
|
pub change: Option<NightChange>,
|
|
}
|
|
|
|
impl From<ActionComplete> for ResponseOutcome {
|
|
fn from(value: ActionComplete) -> Self {
|
|
ResponseOutcome::ActionComplete(value)
|
|
}
|
|
}
|
|
|
|
impl ActionPrompt {
|
|
fn unless(&self) -> Option<Unless> {
|
|
match &self {
|
|
ActionPrompt::Insomniac { .. }
|
|
| ActionPrompt::MasonsWake { .. }
|
|
| ActionPrompt::WolvesIntro { .. }
|
|
| ActionPrompt::RoleChange { .. }
|
|
| ActionPrompt::Shapeshifter { .. }
|
|
| ActionPrompt::ElderReveal { .. }
|
|
| ActionPrompt::CoverOfDarkness => None,
|
|
|
|
ActionPrompt::Arcanist {
|
|
marked: (Some(marked1), Some(marked2)),
|
|
..
|
|
} => Some(Unless::TargetsBlocked(*marked1, *marked2)),
|
|
|
|
ActionPrompt::LoneWolfKill {
|
|
marked: Some(marked),
|
|
..
|
|
}
|
|
| ActionPrompt::Seer {
|
|
marked: Some(marked),
|
|
..
|
|
}
|
|
| ActionPrompt::Protector {
|
|
marked: Some(marked),
|
|
..
|
|
}
|
|
| ActionPrompt::Gravedigger {
|
|
marked: Some(marked),
|
|
..
|
|
}
|
|
| ActionPrompt::Hunter {
|
|
marked: Some(marked),
|
|
..
|
|
}
|
|
| ActionPrompt::Militia {
|
|
marked: Some(marked),
|
|
..
|
|
}
|
|
| ActionPrompt::MapleWolf {
|
|
marked: Some(marked),
|
|
..
|
|
}
|
|
| ActionPrompt::Guardian {
|
|
marked: Some(marked),
|
|
..
|
|
}
|
|
| ActionPrompt::Adjudicator {
|
|
marked: Some(marked),
|
|
..
|
|
}
|
|
| ActionPrompt::PowerSeer {
|
|
marked: Some(marked),
|
|
..
|
|
}
|
|
| ActionPrompt::Mortician {
|
|
marked: Some(marked),
|
|
..
|
|
}
|
|
| ActionPrompt::Beholder {
|
|
marked: Some(marked),
|
|
..
|
|
}
|
|
| ActionPrompt::MasonLeaderRecruit {
|
|
marked: Some(marked),
|
|
..
|
|
}
|
|
| ActionPrompt::Empath {
|
|
marked: Some(marked),
|
|
..
|
|
}
|
|
| ActionPrompt::Vindicator {
|
|
marked: Some(marked),
|
|
..
|
|
}
|
|
| ActionPrompt::PyreMaster {
|
|
marked: Some(marked),
|
|
..
|
|
}
|
|
| ActionPrompt::WolfPackKill {
|
|
marked: Some(marked),
|
|
..
|
|
}
|
|
| ActionPrompt::AlphaWolf {
|
|
marked: Some(marked),
|
|
..
|
|
}
|
|
| ActionPrompt::DireWolf {
|
|
marked: Some(marked),
|
|
..
|
|
} => Some(Unless::TargetBlocked(*marked)),
|
|
|
|
ActionPrompt::LoneWolfKill { marked: None, .. }
|
|
| ActionPrompt::Seer { marked: None, .. }
|
|
| ActionPrompt::Protector { marked: None, .. }
|
|
| ActionPrompt::Gravedigger { marked: None, .. }
|
|
| ActionPrompt::Hunter { marked: None, .. }
|
|
| ActionPrompt::Militia { marked: None, .. }
|
|
| ActionPrompt::MapleWolf { marked: None, .. }
|
|
| ActionPrompt::Guardian { marked: None, .. }
|
|
| ActionPrompt::Adjudicator { marked: None, .. }
|
|
| ActionPrompt::PowerSeer { marked: None, .. }
|
|
| ActionPrompt::Mortician { marked: None, .. }
|
|
| ActionPrompt::Beholder { marked: None, .. }
|
|
| ActionPrompt::MasonLeaderRecruit { marked: None, .. }
|
|
| ActionPrompt::Empath { marked: None, .. }
|
|
| ActionPrompt::Vindicator { marked: None, .. }
|
|
| ActionPrompt::PyreMaster { marked: None, .. }
|
|
| ActionPrompt::WolfPackKill { marked: None, .. }
|
|
| ActionPrompt::AlphaWolf { marked: None, .. }
|
|
| ActionPrompt::DireWolf { marked: None, .. }
|
|
| ActionPrompt::Arcanist {
|
|
marked: (Some(_), None),
|
|
..
|
|
}
|
|
| ActionPrompt::Arcanist {
|
|
marked: (None, Some(_)),
|
|
..
|
|
}
|
|
| ActionPrompt::Arcanist {
|
|
marked: (None, None),
|
|
..
|
|
} => None,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Default for ActionComplete {
|
|
fn default() -> Self {
|
|
Self {
|
|
result: ActionResult::GoBackToSleep,
|
|
change: None,
|
|
}
|
|
}
|
|
}
|
|
|
|
enum Unless {
|
|
TargetBlocked(CharacterId),
|
|
TargetsBlocked(CharacterId, CharacterId),
|
|
}
|
|
|
|
impl From<Unless> for ActionResult {
|
|
fn from(value: Unless) -> Self {
|
|
match value {
|
|
Unless::TargetBlocked(_) | Unless::TargetsBlocked(_, _) => ActionResult::RoleBlocked,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
#[allow(clippy::large_enum_variant)]
|
|
enum NightState {
|
|
Active {
|
|
current_prompt: ActionPrompt,
|
|
current_result: Option<ActionResult>,
|
|
current_changes: Vec<NightChange>,
|
|
current_page: usize,
|
|
},
|
|
Complete,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct Night {
|
|
village: Village,
|
|
night: u8,
|
|
action_queue: VecDeque<ActionPrompt>,
|
|
used_actions: Vec<(ActionPrompt, ActionResult, Vec<NightChange>)>,
|
|
night_state: NightState,
|
|
}
|
|
|
|
impl Night {
|
|
pub fn new(village: Village) -> Result<Self> {
|
|
let night = match village.time() {
|
|
GameTime::Day { number: _ } => return Err(GameError::NotNight),
|
|
GameTime::Night { number } => number,
|
|
};
|
|
|
|
let filter = if village.executed_known_elder() {
|
|
// there is a lynched elder, remove villager PRs from the prompts
|
|
filter::no_village
|
|
} else {
|
|
filter::no_filter
|
|
};
|
|
|
|
let mut action_queue = village
|
|
.characters()
|
|
.into_iter()
|
|
.filter(filter)
|
|
.map(|c| c.night_action_prompts(&village))
|
|
.collect::<Result<Box<[_]>>>()?
|
|
.into_iter()
|
|
.flatten()
|
|
.chain(village.wolf_pack_kill())
|
|
.collect::<Vec<_>>();
|
|
action_queue.sort_by(|left_prompt, right_prompt| {
|
|
left_prompt
|
|
.partial_cmp(right_prompt)
|
|
.unwrap_or(core::cmp::Ordering::Equal)
|
|
});
|
|
let mut action_queue = VecDeque::from(action_queue);
|
|
|
|
if night == 0 {
|
|
action_queue.push_front(ActionPrompt::WolvesIntro {
|
|
wolves: village
|
|
.living_wolf_pack_players()
|
|
.into_iter()
|
|
.map(|w| (w.identity(), w.role_title()))
|
|
.collect(),
|
|
});
|
|
}
|
|
// let current_prompt = action_queue.pop_front().ok_or(GameError::NoNightActions)?;
|
|
let night_state = NightState::Active {
|
|
current_prompt: ActionPrompt::CoverOfDarkness,
|
|
current_changes: Vec::new(),
|
|
current_result: None,
|
|
current_page: 0,
|
|
};
|
|
|
|
Ok(Self {
|
|
night,
|
|
village,
|
|
night_state,
|
|
action_queue,
|
|
used_actions: Vec::new(),
|
|
})
|
|
}
|
|
|
|
/// changes that require no input (such as hunter firing)
|
|
fn automatic_changes(&self) -> Vec<NightChange> {
|
|
let mut changes = Vec::new();
|
|
let night = match NonZeroU8::new(self.night) {
|
|
Some(night) => night,
|
|
None => return changes,
|
|
};
|
|
if !self.village.executed_known_elder() {
|
|
self.village
|
|
.dead_characters()
|
|
.into_iter()
|
|
.filter_map(|c| c.died_to().map(|d| (c, d)))
|
|
.filter_map(|(c, d)| c.hunter().ok().and_then(|h| *h).map(|t| (c, t, d)))
|
|
.filter_map(|(c, t, d)| match d.date_time() {
|
|
GameTime::Day { number } => (number.get() == night.get()).then_some((c, t)),
|
|
GameTime::Night { number: _ } => None,
|
|
})
|
|
.map(|(c, target)| NightChange::Kill {
|
|
target,
|
|
died_to: DiedTo::Hunter {
|
|
night,
|
|
killer: c.character_id(),
|
|
},
|
|
})
|
|
.for_each(|c| changes.push(c));
|
|
}
|
|
|
|
changes
|
|
}
|
|
|
|
pub fn previous_state(&mut self) -> Result<()> {
|
|
let (current_prompt, current_result, current_changes) = match &mut self.night_state {
|
|
NightState::Active {
|
|
current_prompt,
|
|
current_result,
|
|
current_changes,
|
|
current_page,
|
|
} => {
|
|
if let Some(page_back) = current_page.checked_sub(1) {
|
|
*current_page = page_back;
|
|
return Ok(());
|
|
} else {
|
|
(current_prompt, current_result, current_changes)
|
|
}
|
|
}
|
|
NightState::Complete => return Err(GameError::NightOver),
|
|
};
|
|
if let Some((prompt, _, changes)) = self.used_actions.pop() {
|
|
// Remove the shapeshifter role change from the queue
|
|
if let ActionPrompt::Shapeshifter {
|
|
character_id: ss_char,
|
|
} = &prompt
|
|
&& let Some(change) = changes.first()
|
|
&& let NightChange::Shapeshift { source, into } = change
|
|
&& ss_char.character_id == *source
|
|
&& let Some(next) = self.action_queue.pop_front()
|
|
&& let ActionPrompt::RoleChange {
|
|
character_id: role_change_char,
|
|
..
|
|
} = &next
|
|
&& role_change_char.character_id != *into
|
|
{
|
|
// put it back in
|
|
self.action_queue.push_front(next);
|
|
}
|
|
// panic!("{:#?}", self.action_queue.pop_front());
|
|
*current_prompt = prompt;
|
|
*current_result = None;
|
|
*current_changes = Vec::new();
|
|
Ok(())
|
|
} else {
|
|
Err(GameError::NoPreviousState)
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
pub fn action_queue(&self) -> Box<[ActionPrompt]> {
|
|
self.action_queue.iter().cloned().collect()
|
|
}
|
|
|
|
pub fn collect_changes(&self) -> Result<Box<[NightChange]>> {
|
|
if !matches!(self.night_state, NightState::Complete) {
|
|
return Err(GameError::NotEndOfNight);
|
|
}
|
|
let mut all_changes = self.automatic_changes();
|
|
all_changes.append(&mut self.changes_from_actions().into_vec());
|
|
Ok(all_changes.into_boxed_slice())
|
|
}
|
|
|
|
fn apply_mason_recruit(
|
|
&mut self,
|
|
mason_leader: CharacterId,
|
|
recruiting: CharacterId,
|
|
) -> Result<ActionResult> {
|
|
if self.village.character_by_id(recruiting)?.is_village() {
|
|
if let Some(masons) = self.action_queue.iter_mut().find_map(|a| match a {
|
|
ActionPrompt::MasonsWake { leader, masons, .. } => {
|
|
(*leader == mason_leader).then_some(masons)
|
|
}
|
|
_ => None,
|
|
}) {
|
|
let mut ext_masons = masons.to_vec();
|
|
ext_masons.push(self.village.character_by_id(recruiting)?.identity());
|
|
*masons = ext_masons.into_boxed_slice();
|
|
} else {
|
|
self.action_queue.push_front(ActionPrompt::MasonsWake {
|
|
leader: self.village.character_by_id(mason_leader)?.character_id(),
|
|
masons: Box::new([self.village.character_by_id(recruiting)?.identity()]),
|
|
});
|
|
}
|
|
Ok(ActionResult::Continue)
|
|
} else {
|
|
Ok(ActionResult::GoBackToSleep)
|
|
}
|
|
}
|
|
|
|
fn apply_shapeshift(&mut self, source: &CharacterId) -> Result<()> {
|
|
if let Some(kill_target) = self
|
|
.changes_from_actions()
|
|
.into_iter()
|
|
.find_map(|c| match c {
|
|
NightChange::Kill {
|
|
target,
|
|
died_to:
|
|
DiedTo::Wolfpack {
|
|
night: _,
|
|
killing_wolf: _,
|
|
},
|
|
} => Some(target),
|
|
_ => None,
|
|
})
|
|
{
|
|
if self.changes_from_actions().into_iter().any(|c| match c {
|
|
NightChange::Protection {
|
|
target,
|
|
protection: _,
|
|
} => target == kill_target,
|
|
_ => false,
|
|
}) {
|
|
// there is protection, so the kill doesn't happen -> no shapeshift
|
|
return Ok(());
|
|
}
|
|
|
|
if self.changes_from_actions().into_iter().any(|c| {
|
|
matches!(
|
|
c,
|
|
NightChange::Kill {
|
|
target: _,
|
|
died_to: DiedTo::Wolfpack {
|
|
night: _,
|
|
killing_wolf: _
|
|
}
|
|
}
|
|
)
|
|
}) {
|
|
match &mut self.night_state {
|
|
NightState::Active {
|
|
current_changes, ..
|
|
} => current_changes.push(NightChange::Kill {
|
|
target: *source,
|
|
died_to: DiedTo::Shapeshift {
|
|
into: kill_target,
|
|
night: NonZeroU8::new(self.night).unwrap(),
|
|
},
|
|
}),
|
|
_ => return Err(GameError::InvalidMessageForGameState),
|
|
}
|
|
}
|
|
match &mut self.night_state {
|
|
NightState::Active {
|
|
current_changes, ..
|
|
} => current_changes.push(NightChange::Shapeshift {
|
|
source: *source,
|
|
into: kill_target,
|
|
}),
|
|
_ => return Err(GameError::InvalidMessageForGameState),
|
|
}
|
|
self.action_queue.push_front(ActionPrompt::RoleChange {
|
|
new_role: RoleTitle::Werewolf,
|
|
character_id: self.village.character_by_id(kill_target)?.identity(),
|
|
});
|
|
}
|
|
// Remove any further shapeshift prompts from the queue
|
|
let mut new_queue = VecDeque::new();
|
|
while let Some(prompt) = self.action_queue.pop_back() {
|
|
match &prompt {
|
|
ActionPrompt::Shapeshifter { character_id: _ } => {}
|
|
_ => new_queue.push_front(prompt),
|
|
}
|
|
}
|
|
self.action_queue = new_queue;
|
|
Ok(())
|
|
}
|
|
|
|
pub const fn page(&self) -> Option<usize> {
|
|
match &self.night_state {
|
|
NightState::Active { current_page, .. } => Some(*current_page),
|
|
NightState::Complete => None,
|
|
}
|
|
}
|
|
|
|
pub fn received_response(&mut self, resp: ActionResponse) -> Result<ServerAction> {
|
|
match self.received_response_with_role_blocks(resp)? {
|
|
BlockResolvedOutcome::PromptUpdate(prompt) => match &mut self.night_state {
|
|
NightState::Active {
|
|
current_result: Some(_),
|
|
..
|
|
} => Err(GameError::AwaitingResponse),
|
|
NightState::Active { current_prompt, .. } => {
|
|
*current_prompt = prompt.clone();
|
|
Ok(ServerAction::Prompt(prompt))
|
|
}
|
|
NightState::Complete => Err(GameError::NightOver),
|
|
},
|
|
BlockResolvedOutcome::ActionComplete(mut result, Some(change)) => {
|
|
match &mut self.night_state {
|
|
NightState::Active {
|
|
current_prompt: _,
|
|
current_result,
|
|
..
|
|
} => current_result.replace(result.clone()),
|
|
NightState::Complete => return Err(GameError::NightOver),
|
|
};
|
|
if let NightChange::Shapeshift { source, .. } = &change {
|
|
// needs to be resolved _now_ so that the target can be woken
|
|
// for the role change with the wolves
|
|
self.apply_shapeshift(source)?;
|
|
return Ok(ServerAction::Result(
|
|
self.action_queue
|
|
.iter()
|
|
.next()
|
|
.and_then(|a| a.is_wolfy().then_some(ActionResult::Continue))
|
|
.unwrap_or(ActionResult::GoBackToSleep),
|
|
));
|
|
}
|
|
if let NightChange::MasonRecruit {
|
|
mason_leader,
|
|
recruiting,
|
|
} = &change
|
|
{
|
|
result = self.apply_mason_recruit(*mason_leader, *recruiting)?;
|
|
}
|
|
match &mut self.night_state {
|
|
NightState::Active {
|
|
current_changes, ..
|
|
} => current_changes.push(change),
|
|
NightState::Complete => return Err(GameError::InvalidMessageForGameState),
|
|
}
|
|
Ok(ServerAction::Result(result))
|
|
}
|
|
BlockResolvedOutcome::ActionComplete(result, None) => {
|
|
match &mut self.night_state {
|
|
NightState::Active {
|
|
current_prompt: _,
|
|
current_result,
|
|
..
|
|
} => {
|
|
current_result.replace(result.clone());
|
|
}
|
|
NightState::Complete => return Err(GameError::NightOver),
|
|
};
|
|
Ok(ServerAction::Result(result))
|
|
}
|
|
}
|
|
}
|
|
|
|
fn received_response_consecutive_wolves_dont_sleep(
|
|
&self,
|
|
resp: ActionResponse,
|
|
) -> Result<ResponseOutcome> {
|
|
let (current_cover, current_wolfy) = self
|
|
.current_prompt()
|
|
.map(|(current_prompt, _)| {
|
|
(
|
|
*current_prompt == ActionPrompt::CoverOfDarkness,
|
|
current_prompt.is_wolfy(),
|
|
)
|
|
})
|
|
.unwrap_or_default();
|
|
let next_wolfy = self
|
|
.action_queue
|
|
.iter()
|
|
.next()
|
|
.map(|a| a.is_wolfy())
|
|
.unwrap_or_default();
|
|
|
|
if current_cover && let ActionResponse::Continue = &resp {
|
|
return Ok(ResponseOutcome::ActionComplete(ActionComplete {
|
|
result: ActionResult::Continue,
|
|
change: None,
|
|
}));
|
|
}
|
|
|
|
match (self.process(resp)?, current_wolfy, next_wolfy) {
|
|
(ResponseOutcome::PromptUpdate(p), _, _) => Ok(ResponseOutcome::PromptUpdate(p)),
|
|
(
|
|
ResponseOutcome::ActionComplete(ActionComplete {
|
|
result: ActionResult::GoBackToSleep,
|
|
change: Some(NightChange::Shapeshift { source, into }),
|
|
}),
|
|
true,
|
|
_,
|
|
) => Ok(ResponseOutcome::ActionComplete(ActionComplete {
|
|
result: ActionResult::Continue,
|
|
change: Some(NightChange::Shapeshift { source, into }),
|
|
})),
|
|
(
|
|
ResponseOutcome::ActionComplete(ActionComplete {
|
|
result: ActionResult::GoBackToSleep,
|
|
change,
|
|
}),
|
|
true,
|
|
true,
|
|
) => Ok(ResponseOutcome::ActionComplete(ActionComplete {
|
|
result: ActionResult::Continue,
|
|
change,
|
|
})),
|
|
(outcome, _, _) => Ok(outcome),
|
|
}
|
|
}
|
|
|
|
fn received_response_with_role_blocks(
|
|
&self,
|
|
resp: ActionResponse,
|
|
) -> Result<BlockResolvedOutcome> {
|
|
match self.received_response_consecutive_wolves_dont_sleep(resp)? {
|
|
ResponseOutcome::PromptUpdate(update) => Ok(BlockResolvedOutcome::PromptUpdate(update)),
|
|
ResponseOutcome::ActionComplete(ActionComplete { result, change }) => {
|
|
match self
|
|
.current_prompt()
|
|
.ok_or(GameError::NightOver)?
|
|
.0
|
|
.unless()
|
|
{
|
|
Some(Unless::TargetBlocked(unless_blocked)) => {
|
|
if self.changes_from_actions().into_iter().any(|c| match c {
|
|
NightChange::RoleBlock {
|
|
source: _,
|
|
target,
|
|
block_type: _,
|
|
} => target == unless_blocked,
|
|
_ => false,
|
|
}) {
|
|
Ok(BlockResolvedOutcome::ActionComplete(
|
|
ActionResult::RoleBlocked,
|
|
None,
|
|
))
|
|
} else {
|
|
Ok(BlockResolvedOutcome::ActionComplete(result, change))
|
|
}
|
|
}
|
|
Some(Unless::TargetsBlocked(unless_blocked1, unless_blocked2)) => {
|
|
if self.changes_from_actions().into_iter().any(|c| match c {
|
|
NightChange::RoleBlock {
|
|
source: _,
|
|
target,
|
|
block_type: _,
|
|
} => target == unless_blocked1 || target == unless_blocked2,
|
|
_ => false,
|
|
}) {
|
|
Ok(BlockResolvedOutcome::ActionComplete(
|
|
ActionResult::RoleBlocked,
|
|
None,
|
|
))
|
|
} else {
|
|
Ok(BlockResolvedOutcome::ActionComplete(result, change))
|
|
}
|
|
}
|
|
None => Ok(BlockResolvedOutcome::ActionComplete(result, change)),
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub const fn village(&self) -> &Village {
|
|
&self.village
|
|
}
|
|
|
|
pub const fn current_result(&self) -> Option<&ActionResult> {
|
|
match &self.night_state {
|
|
NightState::Active {
|
|
current_prompt: _,
|
|
current_result,
|
|
..
|
|
} => current_result.as_ref(),
|
|
NightState::Complete => None,
|
|
}
|
|
}
|
|
|
|
pub const fn current_prompt(&self) -> Option<(&ActionPrompt, usize)> {
|
|
match &self.night_state {
|
|
NightState::Active {
|
|
current_prompt,
|
|
current_result: _,
|
|
current_page,
|
|
..
|
|
} => Some((current_prompt, *current_page)),
|
|
NightState::Complete => None,
|
|
}
|
|
}
|
|
|
|
pub const fn current_character_id(&self) -> Option<CharacterId> {
|
|
match &self.night_state {
|
|
NightState::Active {
|
|
current_prompt,
|
|
current_result: _,
|
|
..
|
|
} => match current_prompt {
|
|
ActionPrompt::Insomniac { character_id, .. }
|
|
| ActionPrompt::LoneWolfKill { character_id, .. }
|
|
| ActionPrompt::ElderReveal { character_id }
|
|
| ActionPrompt::RoleChange { character_id, .. }
|
|
| ActionPrompt::Seer { character_id, .. }
|
|
| ActionPrompt::Protector { character_id, .. }
|
|
| ActionPrompt::Arcanist { character_id, .. }
|
|
| ActionPrompt::Gravedigger { character_id, .. }
|
|
| ActionPrompt::Hunter { character_id, .. }
|
|
| ActionPrompt::Militia { character_id, .. }
|
|
| ActionPrompt::MapleWolf { character_id, .. }
|
|
| ActionPrompt::Guardian { character_id, .. }
|
|
| ActionPrompt::Shapeshifter { character_id }
|
|
| ActionPrompt::AlphaWolf { character_id, .. }
|
|
| ActionPrompt::Adjudicator { character_id, .. }
|
|
| ActionPrompt::PowerSeer { character_id, .. }
|
|
| ActionPrompt::Mortician { character_id, .. }
|
|
| ActionPrompt::Beholder { character_id, .. }
|
|
| ActionPrompt::MasonLeaderRecruit { character_id, .. }
|
|
| ActionPrompt::Empath { character_id, .. }
|
|
| ActionPrompt::Vindicator { character_id, .. }
|
|
| ActionPrompt::PyreMaster { character_id, .. }
|
|
| ActionPrompt::DireWolf { character_id, .. } => Some(character_id.character_id),
|
|
|
|
ActionPrompt::WolvesIntro { wolves: _ }
|
|
| ActionPrompt::MasonsWake { .. }
|
|
| ActionPrompt::WolfPackKill { .. }
|
|
| ActionPrompt::CoverOfDarkness => None,
|
|
},
|
|
NightState::Complete => None,
|
|
}
|
|
}
|
|
|
|
pub fn current_character(&self) -> Option<&Character> {
|
|
self.current_character_id()
|
|
.and_then(|id| self.village.character_by_id(id).ok())
|
|
}
|
|
|
|
pub const fn complete(&self) -> bool {
|
|
matches!(self.night_state, NightState::Complete)
|
|
}
|
|
|
|
pub fn used_actions(&self) -> Box<[(ActionPrompt, ActionResult)]> {
|
|
self.used_actions
|
|
.iter()
|
|
.map(|(p, r, _)| (p.clone(), r.clone()))
|
|
.collect()
|
|
}
|
|
|
|
pub fn next(&mut self) -> Result<()> {
|
|
match &self.night_state {
|
|
NightState::Active {
|
|
current_prompt,
|
|
current_result: Some(result),
|
|
current_changes,
|
|
..
|
|
} => {
|
|
self.used_actions.push((
|
|
current_prompt.clone(),
|
|
result.clone(),
|
|
current_changes.clone(),
|
|
));
|
|
}
|
|
NightState::Active {
|
|
current_prompt: _,
|
|
current_result: None,
|
|
..
|
|
} => return Err(GameError::AwaitingResponse),
|
|
NightState::Complete => return Err(GameError::NightOver),
|
|
}
|
|
if let Some(prompt) = self.action_queue.pop_front() {
|
|
if let ActionPrompt::Insomniac { character_id } = &prompt
|
|
&& self.get_visits_for(character_id.character_id).is_empty()
|
|
{
|
|
// skip!
|
|
self.used_actions.pop(); // it will be re-added
|
|
return self.next();
|
|
}
|
|
self.night_state = NightState::Active {
|
|
current_prompt: prompt,
|
|
current_result: None,
|
|
current_changes: Vec::new(),
|
|
current_page: 0,
|
|
};
|
|
} else {
|
|
self.night_state = NightState::Complete;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn changes_from_actions(&self) -> Box<[NightChange]> {
|
|
self.used_actions
|
|
.iter()
|
|
.flat_map(|(_, _, act)| act.iter())
|
|
.cloned()
|
|
.collect()
|
|
}
|
|
|
|
pub fn get_visits_for(&self, visit_char: CharacterId) -> Visits {
|
|
Visits::new(
|
|
self.used_actions
|
|
.iter()
|
|
.filter_map(|(prompt, _, _)| match prompt {
|
|
ActionPrompt::Arcanist {
|
|
character_id,
|
|
marked: (Some(marked1), Some(marked2)),
|
|
..
|
|
} => (*marked1 == visit_char || *marked2 == visit_char)
|
|
.then_some(character_id.clone()),
|
|
ActionPrompt::WolfPackKill {
|
|
marked: Some(marked),
|
|
..
|
|
} => (*marked == visit_char)
|
|
.then(|| self.village.killing_wolf().map(|c| c.identity()))
|
|
.flatten(),
|
|
|
|
ActionPrompt::Seer {
|
|
character_id,
|
|
marked: Some(marked),
|
|
..
|
|
}
|
|
| ActionPrompt::Protector {
|
|
character_id,
|
|
marked: Some(marked),
|
|
..
|
|
}
|
|
| ActionPrompt::Gravedigger {
|
|
character_id,
|
|
marked: Some(marked),
|
|
..
|
|
}
|
|
| ActionPrompt::Hunter {
|
|
character_id,
|
|
marked: Some(marked),
|
|
..
|
|
}
|
|
| ActionPrompt::Militia {
|
|
character_id,
|
|
marked: Some(marked),
|
|
..
|
|
}
|
|
| ActionPrompt::MapleWolf {
|
|
character_id,
|
|
marked: Some(marked),
|
|
..
|
|
}
|
|
| ActionPrompt::Guardian {
|
|
character_id,
|
|
marked: Some(marked),
|
|
..
|
|
}
|
|
| ActionPrompt::Adjudicator {
|
|
character_id,
|
|
marked: Some(marked),
|
|
..
|
|
}
|
|
| ActionPrompt::PowerSeer {
|
|
character_id,
|
|
marked: Some(marked),
|
|
..
|
|
}
|
|
| ActionPrompt::Mortician {
|
|
character_id,
|
|
marked: Some(marked),
|
|
..
|
|
}
|
|
| ActionPrompt::Beholder {
|
|
character_id,
|
|
marked: Some(marked),
|
|
..
|
|
}
|
|
| ActionPrompt::MasonLeaderRecruit {
|
|
character_id,
|
|
marked: Some(marked),
|
|
..
|
|
}
|
|
| ActionPrompt::Empath {
|
|
character_id,
|
|
marked: Some(marked),
|
|
..
|
|
}
|
|
| ActionPrompt::Vindicator {
|
|
character_id,
|
|
marked: Some(marked),
|
|
..
|
|
}
|
|
| ActionPrompt::PyreMaster {
|
|
character_id,
|
|
marked: Some(marked),
|
|
..
|
|
}
|
|
| ActionPrompt::AlphaWolf {
|
|
character_id,
|
|
marked: Some(marked),
|
|
..
|
|
}
|
|
| ActionPrompt::DireWolf {
|
|
character_id,
|
|
marked: Some(marked),
|
|
..
|
|
}
|
|
| ActionPrompt::LoneWolfKill {
|
|
character_id,
|
|
marked: Some(marked),
|
|
..
|
|
} => (*marked == visit_char).then(|| character_id.clone()),
|
|
|
|
ActionPrompt::WolfPackKill { marked: None, .. }
|
|
| ActionPrompt::Arcanist { marked: _, .. }
|
|
| ActionPrompt::LoneWolfKill { marked: None, .. }
|
|
| ActionPrompt::Seer { marked: None, .. }
|
|
| ActionPrompt::Protector { marked: None, .. }
|
|
| ActionPrompt::Gravedigger { marked: None, .. }
|
|
| ActionPrompt::Hunter { marked: None, .. }
|
|
| ActionPrompt::Militia { marked: None, .. }
|
|
| ActionPrompt::MapleWolf { marked: None, .. }
|
|
| ActionPrompt::Guardian { marked: None, .. }
|
|
| ActionPrompt::Adjudicator { marked: None, .. }
|
|
| ActionPrompt::PowerSeer { marked: None, .. }
|
|
| ActionPrompt::Mortician { marked: None, .. }
|
|
| ActionPrompt::Beholder { marked: None, .. }
|
|
| ActionPrompt::MasonLeaderRecruit { marked: None, .. }
|
|
| ActionPrompt::Empath { marked: None, .. }
|
|
| ActionPrompt::Vindicator { marked: None, .. }
|
|
| ActionPrompt::PyreMaster { marked: None, .. }
|
|
| ActionPrompt::AlphaWolf { marked: None, .. }
|
|
| ActionPrompt::DireWolf { marked: None, .. }
|
|
| ActionPrompt::CoverOfDarkness
|
|
| ActionPrompt::WolvesIntro { .. }
|
|
| ActionPrompt::RoleChange { .. }
|
|
| ActionPrompt::ElderReveal { .. }
|
|
| ActionPrompt::Shapeshifter { .. }
|
|
| ActionPrompt::MasonsWake { .. }
|
|
| ActionPrompt::Insomniac { .. } => None,
|
|
})
|
|
.collect(),
|
|
)
|
|
}
|
|
|
|
pub fn next_page(&mut self) {
|
|
if let NightState::Active { current_page, .. } = &mut self.night_state {
|
|
*current_page += 1
|
|
}
|
|
}
|
|
}
|
|
|
|
pub enum ServerAction {
|
|
Prompt(ActionPrompt),
|
|
Result(ActionResult),
|
|
}
|
|
|
|
mod filter {
|
|
use crate::character::Character;
|
|
|
|
pub fn no_filter(_: &Character) -> bool {
|
|
true
|
|
}
|
|
|
|
pub fn no_village(c: &Character) -> bool {
|
|
!c.is_village()
|
|
}
|
|
}
|