games-rs 0.5.0

Pre-implemented games written in rust.
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

//! Coin Toss, make a prediction on which side the coin will land
//! ```rust
//! use games::coin_toss::*;
//! fn main() -> Result<(), CoinError> {
//!     // Method A
//!     if CoinToss::guess(Coin::Heads).is_correct() {
//!         println!("You guessed correctly for A");
//!     }
//!     // Method B
//!     if CoinToss::guess("Heads".parse()?).is_correct() {
//!         println!("You guessed correctly for B");
//!     }
//!     // Method C
//!     if CoinToss::guess(Coin::flip()).is_correct() {
//!         println!("Fate loves you");
//!     }
//!     Ok(())
//! }
//! ```
use crate::errors::{BASE_COIN_TOSS_ERROR_CODE, ErrorCode};

use core::fmt;

use rand::RngExt;

/// Error raised by Coin Toss
#[repr(C)]
#[derive(
    Debug, Copy, Clone, serde::Serialize, serde::Deserialize, Eq, PartialEq, PartialOrd, Ord, Hash,
)]
pub enum CoinError {
    /// Failed to parse coin side (5001)
    InvalidSideError,
}

impl fmt::Display for CoinError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            CoinError::InvalidSideError => f.write_str("Not a valid side"),
        }
    }
}

impl ErrorCode for CoinError {
    fn error_code(&self) -> i32 {
        BASE_COIN_TOSS_ERROR_CODE
            + match *self {
                CoinError::InvalidSideError => 1,
            }
    }
}

/// Enum representing a coin
#[derive(
    Clone, Copy, Debug, Eq, Hash, PartialEq, PartialOrd, Ord, serde::Serialize, serde::Deserialize,
)]
pub enum Coin {
    /// Head side of the coin
    Heads,
    /// Tails side of the coin
    Tails,
}

impl Coin {
    /// Flips a coin, returning a Coin with its current Side up
    pub fn flip() -> Coin {
        Coin::from(crate::get_rng().random_bool(0.5))
    }
}

impl fmt::Display for Coin {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Coin::Heads => f.write_str("Heads"),
            Coin::Tails => f.write_str("Tails"),
        }
    }
}

/// Coin toss struct
#[derive(
    Copy, Clone, Debug, serde::Serialize, serde::Deserialize, Ord, PartialOrd, PartialEq, Eq, Hash,
)]
pub struct CoinToss {
    /// The coin's state that the player guessed
    pub guess: Coin,
    /// The coin's state that happened after the toss
    pub real: Coin,
}

impl From<CoinToss> for bool {
    fn from(val: CoinToss) -> Self {
        val.guess == val.real
    }
}

impl core::str::FromStr for Coin {
    type Err = CoinError;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let guess = s.to_ascii_lowercase();
        if ["heads", "h", "t", "tails"].contains(&guess.as_str()) {
            Ok(Coin::from(guess.starts_with('h')))
        } else {
            Err(CoinError::InvalidSideError)
        }
    }
}

impl From<bool> for Coin {
    fn from(b: bool) -> Coin {
        if b { Coin::Heads } else { Coin::Tails }
    }
}

impl fmt::Display for CoinToss {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Guess: {}\nResult: {}", self.guess, self.real)
    }
}

impl CoinToss {
    /// Make a guess on what side the coin will land on
    pub fn guess(guess: Coin) -> Self {
        CoinToss {
            guess,
            real: Coin::flip(),
        }
    }
    /// Returns if the guess was correct
    pub fn is_correct(self) -> bool {
        self.real == self.guess
    }
}