tokyodoves 1.0.2

A library of an efficient board of Tokyo Doves and associated toolkits
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

//! Move rules of each dove

use array_macro::array;

use super::bitutil;
use crate::prelude::{macros, Dove, Shift};

const BIT_ROUTE_SHIFTS: [TargetBitRouteShift; 64] = {
    array![
        n => TargetBitRouteShift::create_from_origin(1 << n); 64
    ]
};

pub fn bit_route_shift(bit: u64, dove: Dove) -> &'static [(u64, u64, (i8, i8))] {
    let idx = bit.trailing_zeros() as usize;
    BIT_ROUTE_SHIFTS[idx].bit_route_shift(dove)
}

#[derive(Debug, Clone, Copy)]
struct TargetBitRouteShift {
    b: [(u64, u64, (i8, i8)); 8],
    a: [(u64, u64, (i8, i8)); 8],
    y: [(u64, u64, (i8, i8)); 4],
    m: [(u64, u64, (i8, i8)); 4],
    t: [(u64, u64, (i8, i8)); 16],
    h: [(u64, u64, (i8, i8)); 8],
}

impl TargetBitRouteShift {
    const fn create_from_origin(origin_bit: u64) -> Self {
        let ba_shifts = [
            (-1, -1),
            (0, -1),
            (1, -1),
            (-1, 0),
            (1, 0),
            (-1, 1),
            (0, 1),
            (1, 1),
        ];
        let b = Self::make_bits_from_shifts(origin_bit, ba_shifts);
        let a = Self::make_bits_from_shifts(origin_bit, ba_shifts);

        let y_shifts = [(0, -1), (-1, 0), (1, 0), (0, 1)];
        let y = Self::make_bits_from_shifts(origin_bit, y_shifts);

        let m_shifts = [(-1, -1), (1, -1), (-1, 1), (1, 1)];
        let m = Self::make_bits_from_shifts(origin_bit, m_shifts);

        let t = Self::make_bits_t(origin_bit);

        let h_shifts = [
            (-1, -2),
            (1, -2),
            (-2, -1),
            (2, -1),
            (-2, 1),
            (2, 1),
            (-1, 2),
            (1, 2),
        ];
        let h = Self::make_bits_from_shifts(origin_bit, h_shifts);

        Self { b, a, y, m, t, h }
    }

    fn bit_route_shift(&self, dove_type: Dove) -> &[(u64, u64, (i8, i8))] {
        use Dove::*;
        match dove_type {
            B => &self.b,
            A => &self.a,
            Y => &self.y,
            M => &self.m,
            T => &self.t,
            H => &self.h,
        }
    }

    const fn make_bits_from_shifts<const N: usize>(
        origin_bit: u64,
        shifts: [(i8, i8); N],
    ) -> [(u64, u64, (i8, i8)); N] {
        let bits = array![
            n => {
                let shift = Shift { dh: shifts[n].0, dv: shifts[n].1 };
                let bit = bitutil::apply_shift(origin_bit, shift);
                (bit, bit, shifts[n])
            }; N
        ];
        bits
    }

    const fn make_bits_t(origin_bit: u64) -> [(u64, u64, (i8, i8)); 16] {
        // Note: the order of contents affects pack_moves
        let mut t = [(0, 0, (0, 0)); 16];

        macro_rules! define_route_t {
            ($({$i:ident, $dh:expr, $dv:expr, $idx:expr})*) => {
                $(
                    let mut route = 0;
                    macros::for_loop!(let mut $i = 0; $i < 4; $i += 1 => {
                        let shift = Shift {
                            dh: $dh,
                            dv: $dv,
                        };
                        let bit = bitutil::apply_shift(origin_bit, shift);
                        route |= bit;
                        t[($idx) as usize] = (bit, route, ($dh, $dv));
                    });
                )*
            };
        }

        define_route_t!(
            { i, 0, -(i + 1), i }
            { i, -(i + 1), 0, i + 4 }
            { i, i + 1, 0, i + 8 }
            { i, 0, i + 1, i + 12 }
        );

        t
    }
}