libcoinche 0.1.2

A library to model the Coinche card game.
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

//! Player position in the table

use rustc_serialize;

/// One of two teams
#[derive(PartialEq,Clone,Copy,Debug)]
pub struct Team(pub usize);

impl rustc_serialize::Encodable for Team {
    fn encode<S: rustc_serialize::Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
        self.0.encode(s)
    }
}

impl Team {
    /// Returns the other team
    pub fn opponent(self) -> Team {
        Team(1 - self.0)
    }
}

/// A position in the table
#[derive(PartialEq,Clone,Copy,Debug)]
pub struct PlayerPos(pub usize);

impl rustc_serialize::Encodable for PlayerPos {
    fn encode<S: rustc_serialize::Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
        self.0.encode(s)
    }
}

/// Iterates on players
pub struct PlayerIterator {
    current: PlayerPos,
    remaining: usize,
}

impl Iterator for PlayerIterator {
    type Item = PlayerPos;

    fn next(&mut self) -> Option<PlayerPos> {
        if self.remaining == 0 {
            return None;
        }

        let r = self.current;
        self.current = self.current.next();
        self.remaining -= 1;
        Some(r)
    }
}

/// Player 0
pub const P0: PlayerPos = PlayerPos(0);
/// Player 1
pub const P1: PlayerPos = PlayerPos(1);
/// Player 2
pub const P2: PlayerPos = PlayerPos(2);
/// Player 3
pub const P3: PlayerPos = PlayerPos(3);

impl PlayerPos {
    /// Returns the player's team
    pub fn team(self) -> Team {
        Team(self.0 % 2)
    }

    /// Returns `true` if `self` and `other` and in the same team
    pub fn is_partner(self, other: PlayerPos) -> bool {
        self.team() == other.team()
    }

    /// Returns the next player in line
    pub fn next(self) -> PlayerPos {
        if self == P3 {
            P0
        } else {
            PlayerPos(self.0+1)
        }
    }

    /// Returns the player `n` seats further
    pub fn next_n(self, n: usize) -> PlayerPos {
        if n == 0 {
            self
        } else {
            PlayerPos((self.0 + n) % 4)
        }
    }

    /// Returns the previous player.
    pub fn prev(self) -> PlayerPos {
        if self == P0 {
            P3
        } else {
            PlayerPos(self.0 - 1)
        }
    }

    /// Returns an iterator that iterates on `n` players, including this one.
    pub fn until_n(self, n: usize) -> PlayerIterator {
        PlayerIterator {
            current:self,
            remaining: n,
        }
    }

    /// Returns the number of turns after `self` to reach `other`.
    pub fn distance_until(self, other: PlayerPos) -> usize {
        (3 + other.0 - self.0) % 4 + 1
    }

    /// Returns an iterator until the given player (`self` included, `other` excluded)
    pub fn until(self, other: PlayerPos) -> PlayerIterator {
        let d = self.distance_until(other);
        self.until_n(d)
    }
}

#[cfg(test)]
mod tests {

    use super::*;

    #[test]
    fn test_pos() {
        let mut count = [0; 4];
        for i in 0..4 {
            for pos in PlayerPos(i).until(PlayerPos(0)) {
                count[pos.0] += 1;
            }
            for pos in PlayerPos(0).until(PlayerPos(i)) {
                count[pos.0] += 1;
            }
        }

        for c in count.iter() {
            assert!(*c == 5);
        }

        for i in 0..4 {
            assert!(PlayerPos(i).next() == PlayerPos((i+1)%4));
            assert!(PlayerPos(i) == PlayerPos((i+1)%4).prev());
            assert!(PlayerPos(i).next().prev() == PlayerPos(i));
        }
    }
}