tic_tac_toe_bit_patterns 1.0.0

An implementation of Tic-Tac-Toe
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

//! Helper module for [WinPattern]

use std::fmt::{Binary, Display};
use std::ops::{BitAnd, BitOr, BitXor, Shr};

use super::{Cell, WinPattern};

impl From<WinPattern> for u32 {
    /// Converts a [WinPattern] into a [u32]
    fn from(x: WinPattern) -> Self {
        x as u32
    }
}

impl From<WinPattern> for [Cell; 3] {
    /// Converts a [WinPattern] into a triple of [Cell]s `[Cell; 3]`
    fn from(val: WinPattern) -> Self {
        match val {
            WinPattern::TopRow => [Cell::TopLeft, Cell::TopCentre, Cell::TopRight],
            WinPattern::CentreRow => [Cell::CentreLeft, Cell::Centre, Cell::CentreRight],
            WinPattern::BottomRow => [Cell::BottomLeft, Cell::BottomCentre, Cell::BottomRight],
            WinPattern::LeftColumn => [Cell::TopLeft, Cell::CentreLeft, Cell::BottomLeft],
            WinPattern::CentreColumn => [Cell::TopCentre, Cell::Centre, Cell::BottomCentre],
            WinPattern::RightColumn => [Cell::TopRight, Cell::CentreRight, Cell::BottomRight],
            WinPattern::LeftDiagonal => [Cell::TopLeft, Cell::Centre, Cell::BottomRight],
            WinPattern::RightDiagonal => [Cell::TopRight, Cell::Centre, Cell::BottomLeft],
        }
    }
}

impl Display for WinPattern {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{:>32b}", *self as u32)
    }
}

impl Binary for WinPattern {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        Binary::fmt(&u32::from(*self), f)
    }
}

impl Shr<u32> for WinPattern {
    type Output = u32;

    fn shr(self, rhs: u32) -> Self::Output {
        self as u32 >> rhs
    }
}

impl BitOr<WinPattern> for u32 {
    type Output = u32;

    fn bitor(self, rhs: WinPattern) -> Self::Output {
        self | rhs as u32
    }
}

impl BitOr<u32> for WinPattern {
    type Output = u32;

    fn bitor(self, rhs: u32) -> Self::Output {
        self as u32 | rhs
    }
}

impl BitXor<WinPattern> for u32 {
    type Output = u32;

    fn bitxor(self, rhs: WinPattern) -> Self::Output {
        self ^ rhs as u32
    }
}

impl BitXor<u32> for WinPattern {
    type Output = u32;

    fn bitxor(self, rhs: u32) -> Self::Output {
        self as u32 ^ rhs
    }
}

impl BitAnd<WinPattern> for u32 {
    type Output = u32;

    fn bitand(self, rhs: WinPattern) -> Self::Output {
        self & rhs as u32
    }
}

impl BitAnd<u32> for WinPattern {
    type Output = u32;

    fn bitand(self, rhs: u32) -> Self::Output {
        self as u32 & rhs
    }
}