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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

//! A [`SearchChoose`] strategy which allows the user to input the next [`Action`] via stdin.

use std::error::Error;
use std::fmt::Debug;
use std::io::{self, Write};
use std::str::FromStr;

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

/// Errors related to the [`UserInput`] [`SearchChoose`].
#[derive(Debug, thiserror::Error)]
pub enum UserInputError<const N: usize, G: Game<N>>
where
    G::Action: FromStr + Debug,
    <G::Action as FromStr>::Err: Error,
{
    /// Error returned in the stdin/stdout IO.
    #[error(transparent)]
    IoError(#[from] io::Error),

    /// Error parsing an [`Action`].
    #[error(transparent)]
    ParseError(<G::Action as FromStr>::Err),

    /// Error returned by the [`Game`].
    #[error(transparent)]
    GameError(G::Error),

    /// The provided action is not valid at the current [`Game`] [`State`].
    #[error("Action {0:?} is not valid at the current game state")]
    InvalidGameAction(G::Action),
}

impl<const N: usize, G: Game<N>> SearchError for UserInputError<N, G>
where
    G::Action: FromStr + Debug,
    <G::Action as FromStr>::Err: Error,
{
}

impl<const N: usize, G: Game<N, Error = E>, E: GameError> From<E> for UserInputError<N, G>
where
    G::Action: FromStr + Debug,
    <G::Action as FromStr>::Err: Error,
{
    fn from(value: G::Error) -> Self {
        Self::GameError(value)
    }
}

/// A "search" algorithm that prompts the user for input on which [`Action`] to take.
#[derive(Debug)]
pub struct UserInput {
    /// The prompt to show when the user is asked to select an [`Action`].
    prompt: String,
    /// The number of retries a user is given in case of an error.
    ///
    /// Retries are allowed if (1) there is an error parsing the string to an [`Action`]
    /// or (2) the parsed [`Action`] is not valid at the current [`Game`] [`State`].
    parse_retries: usize,
}

impl Default for UserInput {
    fn default() -> Self {
        Self {
            prompt: "User input".into(),
            parse_retries: 0,
        }
    }
}

impl UserInput {
    /// Initialize a new user input.
    pub fn new(prompt: impl ToString, parse_retries: usize) -> Self {
        Self {
            prompt: prompt.to_string(),
            parse_retries,
        }
    }

    fn parse_action<const N: usize, G: Game<N>>(
        &self,
        retry: usize,
        game: &G,
        state: &G::State,
    ) -> Result<<G as Game<N>>::Action, UserInputError<N, G>>
    where
        G::Action: FromUserInput + PartialEq + Debug,
        <G::Action as FromStr>::Err: Error,
    {
        let mut buffer = String::new();
        let stdin = io::stdin();
        let active_player = game.active_player(state)?;
        if let Some(hint) = <G::Action as FromUserInput>::HINT {
            print!("{} [{active_player:?}] ({}): ", self.prompt, hint);
        } else {
            print!("{} [{active_player:?}]: ", self.prompt);
        }
        io::stdout().flush()?;
        stdin.read_line(&mut buffer)?;
        let input = buffer.trim_end();

        let action = match input.parse() {
            Ok(action) => {
                if game.available_actions(state)?.contains(&action) {
                    Ok(action)
                } else {
                    log::warn!(
                        "Parsed action {:?}, but this is not a valid action at this game state",
                        action
                    );
                    Err(UserInputError::InvalidGameAction(action))
                }
            }
            Err(e) => {
                log::warn!("Unable to parse {} to expected action format", input);
                Err(UserInputError::ParseError(e))
            }
        };

        if action.is_err() && retry < self.parse_retries {
            log::info!("Giving the user another opportunity to input");
            self.parse_action::<N, G>(retry + 1, game, state)
        } else {
            action
        }
    }
}

impl<const N: usize, G: Game<N>> SearchChoose<N, G> for UserInput
where
    G::Action: FromUserInput + Debug + PartialEq,
    <G::Action as FromStr>::Err: Error,
{
    type Error = UserInputError<N, G>;

    fn choose_action(
        &self,
        game: &G,
        state: &G::State,
    ) -> Result<Option<G::Action>, UserInputError<N, G>> {
        let action = self.parse_action::<N, G>(0, game, state)?;
        Ok(Some(action))
    }
}

/// An [`Action`] must implement this for the [`Game`] to be usable with [`UserInput`].
pub trait FromUserInput: FromStr {
    /// An optional hint to provide the user with about the expected format for successful parsing.
    ///
    /// This will be included with the prompt if provided.
    const HINT: Option<&'static str> = None;
}