ncpig 0.6.1

Non-Cooperative Perfect Information Games, and algorithms to play them.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

//! Have [`search`] algorithms compete against each other in a [`Game`].

use std::fmt::{Debug, Display};

#[cfg(doc)]
use crate::game::State;
use crate::game::{Game, GameError};
#[cfg(doc)]
use crate::search;
use crate::search::{SearchChoose, SearchError};

/// Errors that could occur in a [`Competition`].
#[derive(Debug, thiserror::Error)]
pub enum CompetitionError<const N: usize, G: Game<N>> {
    /// Error occured in the [`Game`].
    #[error(transparent)]
    GameError(G::Error),

    /// Error occured in one of the [`SearchChoose`] algorithms.
    #[error("{0}")]
    SearchError(Box<dyn SearchError + Send + Sync>),

    /// No actions to take
    #[error("No actions are available to take")]
    NoActions,
}

/// Manually implement the conversion from [`Game::Error`] to [`CompetitionError`].
impl<const N: usize, G: Game<N, Error = E>, E: GameError> From<E> for CompetitionError<N, G> {
    fn from(value: G::Error) -> Self {
        Self::GameError(value)
    }
}

/// Allow a [`SearchChoose`] (or something else) to be used in a [`Competition`].
pub trait CompetitionStrategy<const N: usize, G: Game<N>>: Debug {
    /// Take a turn given the current strategy.
    fn take_turn(&self, game: &G, state: G::State) -> Result<G::State, CompetitionError<N, G>>;
}

/// Blanket implement [`CompetitionStrategy`] for all [`SearchChoose`]es than can be.
impl<const N: usize, G: Game<N>, T: SearchChoose<N, G> + Debug> CompetitionStrategy<N, G> for T
where
    <T as SearchChoose<N, G>>::Error: Send + Sync + 'static,
    G::Action: Debug,
{
    fn take_turn(&self, game: &G, state: G::State) -> Result<G::State, CompetitionError<N, G>> {
        let action = self
            .choose_action(game, &state)
            .map_err(|err| CompetitionError::SearchError(Box::new(err)))?
            .ok_or(CompetitionError::NoActions)?;
        log::debug!("Strategy has determined action {:?}", action);
        Ok(game.do_action(&action, state)?)
    }
}

/// Pit different strategies against each other in an `N`-player [`Game`].
pub struct Competition<'a, const N: usize, G: Game<N>> {
    /// The game being played.
    game: &'a G,
    /// The strategies for each player, in the same order as [`Game.players`].
    strategies: [&'a dyn CompetitionStrategy<N, G>; N],
    /// Whether to display the [`State`] of the game at each turn.
    display_state: bool,
}

impl<'a, const N: usize, G: Game<N>> Competition<'a, N, G> {
    /// Create a new [`Competition`].
    pub fn new(
        game: &'a G,
        strategies: [&'a dyn CompetitionStrategy<N, G>; N],
        display_state: bool,
    ) -> Self {
        Self {
            game,
            strategies,
            display_state,
        }
    }

    /// Let the players play.
    ///
    /// The [`State`] will be mutated and can be inspected afterwards to determined the
    /// winner and/or other info.
    pub fn play(&'a self, state: G::State) -> Result<G::State, CompetitionError<N, G>>
    where
        G::State: Display,
    {
        let mut state = state;
        log::info!("Starting competition");
        while !self.game.is_complete(&state)? {
            if self.display_state {
                println!("{}\n", state);
            }
            let current_player = self.game.active_player(&state)?;

            let current_player_index = self.game.player_index(current_player)?;
            log::trace!(
                "Player {:?} has player index {}",
                current_player,
                current_player_index
            );

            let strategy = &self.strategies[current_player_index];
            log::info!(
                "Player {:?} taking turn with strategy {:?}",
                current_player,
                strategy
            );

            state = strategy.take_turn(self.game, state)?;
        }
        log::info!("Competition is complete because game is over");
        if self.display_state {
            println!("{}\n", state);
        }
        Ok(state)
    }
}