pokers 0.10.0

Rust Poker Library
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

use super::Hand;
use crate::constants::*;

pub static CARDS: [Hand; 52] = [
    Hand { key: (1u64 << (4 * (0 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[0 >> 2], mask: (1u64 << ((3 - (0 & 3)) * 16 + (0 >> 2)))},
    Hand { key: (1u64 << (4 * (1 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[1 >> 2], mask: (1u64 << ((3 - (1 & 3)) * 16 + (1 >> 2)))},
    Hand { key: (1u64 << (4 * (2 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[2 >> 2], mask: (1u64 << ((3 - (2 & 3)) * 16 + (2 >> 2)))},
    Hand { key: (1u64 << (4 * (3 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[3 >> 2], mask: (1u64 << ((3 - (3 & 3)) * 16 + (3 >> 2)))},
    Hand { key: (1u64 << (4 * (4 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[4 >> 2], mask: (1u64 << ((3 - (4 & 3)) * 16 + (4 >> 2)))},
    Hand { key: (1u64 << (4 * (5 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[5 >> 2], mask: (1u64 << ((3 - (5 & 3)) * 16 + (5 >> 2)))},
    Hand { key: (1u64 << (4 * (6 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[6 >> 2], mask: (1u64 << ((3 - (6 & 3)) * 16 + (6 >> 2)))},
    Hand { key: (1u64 << (4 * (7 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[7 >> 2], mask: (1u64 << ((3 - (7 & 3)) * 16 + (7 >> 2)))},
    Hand { key: (1u64 << (4 * (8 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[8 >> 2], mask: (1u64 << ((3 - (8 & 3)) * 16 + (8 >> 2)))},
    Hand { key: (1u64 << (4 * (9 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[9 >> 2], mask: (1u64 << ((3 - (9 & 3)) * 16 + (9 >> 2)))},
    Hand { key: (1u64 << (4 * (10 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[10 >> 2], mask: (1u64 << ((3 - (10 & 3)) * 16 + (10 >> 2)))},
    Hand { key: (1u64 << (4 * (11 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[11 >> 2], mask: (1u64 << ((3 - (11 & 3)) * 16 + (11 >> 2)))},
    Hand { key: (1u64 << (4 * (12 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[12 >> 2], mask: (1u64 << ((3 - (12 & 3)) * 16 + (12 >> 2)))},
    Hand { key: (1u64 << (4 * (13 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[13 >> 2], mask: (1u64 << ((3 - (13 & 3)) * 16 + (13 >> 2)))},
    Hand { key: (1u64 << (4 * (14 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[14 >> 2], mask: (1u64 << ((3 - (14 & 3)) * 16 + (14 >> 2)))},
    Hand { key: (1u64 << (4 * (15 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[15 >> 2], mask: (1u64 << ((3 - (15 & 3)) * 16 + (15 >> 2)))},
    Hand { key: (1u64 << (4 * (16 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[16 >> 2], mask: (1u64 << ((3 - (16 & 3)) * 16 + (16 >> 2)))},
    Hand { key: (1u64 << (4 * (17 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[17 >> 2], mask: (1u64 << ((3 - (17 & 3)) * 16 + (17 >> 2)))},
    Hand { key: (1u64 << (4 * (18 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[18 >> 2], mask: (1u64 << ((3 - (18 & 3)) * 16 + (18 >> 2)))},
    Hand { key: (1u64 << (4 * (19 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[19 >> 2], mask: (1u64 << ((3 - (19 & 3)) * 16 + (19 >> 2)))},
    Hand { key: (1u64 << (4 * (20 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[20 >> 2], mask: (1u64 << ((3 - (20 & 3)) * 16 + (20 >> 2)))},
    Hand { key: (1u64 << (4 * (21 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[21 >> 2], mask: (1u64 << ((3 - (21 & 3)) * 16 + (21 >> 2)))},
    Hand { key: (1u64 << (4 * (22 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[22 >> 2], mask: (1u64 << ((3 - (22 & 3)) * 16 + (22 >> 2)))},
    Hand { key: (1u64 << (4 * (23 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[23 >> 2], mask: (1u64 << ((3 - (23 & 3)) * 16 + (23 >> 2)))},
    Hand { key: (1u64 << (4 * (24 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[24 >> 2], mask: (1u64 << ((3 - (24 & 3)) * 16 + (24 >> 2)))},
    Hand { key: (1u64 << (4 * (25 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[25 >> 2], mask: (1u64 << ((3 - (25 & 3)) * 16 + (25 >> 2)))},
    Hand { key: (1u64 << (4 * (26 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[26 >> 2], mask: (1u64 << ((3 - (26 & 3)) * 16 + (26 >> 2)))},
    Hand { key: (1u64 << (4 * (27 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[27 >> 2], mask: (1u64 << ((3 - (27 & 3)) * 16 + (27 >> 2)))},
    Hand { key: (1u64 << (4 * (28 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[28 >> 2], mask: (1u64 << ((3 - (28 & 3)) * 16 + (28 >> 2)))},
    Hand { key: (1u64 << (4 * (29 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[29 >> 2], mask: (1u64 << ((3 - (29 & 3)) * 16 + (29 >> 2)))},
    Hand { key: (1u64 << (4 * (30 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[30 >> 2], mask: (1u64 << ((3 - (30 & 3)) * 16 + (30 >> 2)))},
    Hand { key: (1u64 << (4 * (31 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[31 >> 2], mask: (1u64 << ((3 - (31 & 3)) * 16 + (31 >> 2)))},
    Hand { key: (1u64 << (4 * (32 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[32 >> 2], mask: (1u64 << ((3 - (32 & 3)) * 16 + (32 >> 2)))},
    Hand { key: (1u64 << (4 * (33 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[33 >> 2], mask: (1u64 << ((3 - (33 & 3)) * 16 + (33 >> 2)))},
    Hand { key: (1u64 << (4 * (34 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[34 >> 2], mask: (1u64 << ((3 - (34 & 3)) * 16 + (34 >> 2)))},
    Hand { key: (1u64 << (4 * (35 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[35 >> 2], mask: (1u64 << ((3 - (35 & 3)) * 16 + (35 >> 2)))},
    Hand { key: (1u64 << (4 * (36 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[36 >> 2], mask: (1u64 << ((3 - (36 & 3)) * 16 + (36 >> 2)))},
    Hand { key: (1u64 << (4 * (37 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[37 >> 2], mask: (1u64 << ((3 - (37 & 3)) * 16 + (37 >> 2)))},
    Hand { key: (1u64 << (4 * (38 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[38 >> 2], mask: (1u64 << ((3 - (38 & 3)) * 16 + (38 >> 2)))},
    Hand { key: (1u64 << (4 * (39 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[39 >> 2], mask: (1u64 << ((3 - (39 & 3)) * 16 + (39 >> 2)))},
    Hand { key: (1u64 << (4 * (40 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[40 >> 2], mask: (1u64 << ((3 - (40 & 3)) * 16 + (40 >> 2)))},
    Hand { key: (1u64 << (4 * (41 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[41 >> 2], mask: (1u64 << ((3 - (41 & 3)) * 16 + (41 >> 2)))},
    Hand { key: (1u64 << (4 * (42 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[42 >> 2], mask: (1u64 << ((3 - (42 & 3)) * 16 + (42 >> 2)))},
    Hand { key: (1u64 << (4 * (43 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[43 >> 2], mask: (1u64 << ((3 - (43 & 3)) * 16 + (43 >> 2)))},
    Hand { key: (1u64 << (4 * (44 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[44 >> 2], mask: (1u64 << ((3 - (44 & 3)) * 16 + (44 >> 2)))},
    Hand { key: (1u64 << (4 * (45 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[45 >> 2], mask: (1u64 << ((3 - (45 & 3)) * 16 + (45 >> 2)))},
    Hand { key: (1u64 << (4 * (46 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[46 >> 2], mask: (1u64 << ((3 - (46 & 3)) * 16 + (46 >> 2)))},
    Hand { key: (1u64 << (4 * (47 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[47 >> 2], mask: (1u64 << ((3 - (47 & 3)) * 16 + (47 >> 2)))},
    Hand { key: (1u64 << (4 * (48 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[48 >> 2], mask: (1u64 << ((3 - (48 & 3)) * 16 + (48 >> 2)))},
    Hand { key: (1u64 << (4 * (49 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[49 >> 2], mask: (1u64 << ((3 - (49 & 3)) * 16 + (49 >> 2)))},
    Hand { key: (1u64 << (4 * (50 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[50 >> 2], mask: (1u64 << ((3 - (50 & 3)) * 16 + (50 >> 2)))},
    Hand { key: (1u64 << (4 * (51 & 3) + SUITS_SHIFT)) + (1u64 << CARD_COUNT_SHIFT) + RANKS[51 >> 2], mask: (1u64 << ((3 - (51 & 3)) * 16 + (51 >> 2)))},
];