sisyphus32 1.3.1

Feature-based UCI Chess Engine
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

use crate::{Bitboard, SQUARE_COUNT, MoveMasks, RandomNumberGenerator, Square};

const MAX_SLIDER_MOVE_PERMUTATIONS: usize = 4096;
const NUM_CANDIDATES: usize = 10_000_000;

#[derive(Default)]
pub(crate) struct MagicNumberGenerator {
    rng: RandomNumberGenerator
}

impl MagicNumberGenerator {
    fn generate_magic_number_candidate(&mut self) -> u64 {
        self.rng.generate_sparse_u64()
    }

    pub(crate) fn generate_magic_number(&mut self, square: Square, num_relevant_bits: u8, is_bishop: bool) -> u64 {
        let mut occupancies = [Bitboard::EMPTY; MAX_SLIDER_MOVE_PERMUTATIONS];
        let mut moves = [Bitboard::EMPTY; MAX_SLIDER_MOVE_PERMUTATIONS];
        let mask = if is_bishop { MoveMasks::get_bishop_base_mask(square) } else { MoveMasks::get_rook_base_mask(square) };
        let max_occupancy_index = 1 << num_relevant_bits;

        for i in 0..max_occupancy_index {
            occupancies[i] = MoveMasks::generate_occupancy_permutation(i as u32, num_relevant_bits, mask);
            
            if is_bishop {
                moves[i] = MoveMasks::generate_bishop_moves_on_the_fly(square, occupancies[i]);
            } else {
                moves[i] = MoveMasks::generate_rook_moves_on_the_fly(square, occupancies[i]);
            }
        }

        for _ in 0..NUM_CANDIDATES {
            let magic_number_candidate = self.generate_magic_number_candidate();
            
            // Skip inappropriate magic numbers
            if Bitboard(mask.0.wrapping_mul(magic_number_candidate) & 0xFF00000000000000).count_bits() < 6 {
                continue;
            }

            let mut used_moves = [Bitboard::EMPTY; MAX_SLIDER_MOVE_PERMUTATIONS];

            let mut failed = false;
            for i in 0..max_occupancy_index {
                if failed { break };

                let magic_index = ((occupancies[i].0.wrapping_mul(magic_number_candidate)) >> (SQUARE_COUNT as u8 - num_relevant_bits)) as usize;

                if used_moves[magic_index].is_empty() {
                    used_moves[magic_index] = moves[i];
                } else if used_moves[magic_index] != moves[i] {
                    failed = true;
                }
            }

            if !failed {
                return magic_number_candidate;
            }
        }

        panic!("No magic number could be found");
    }

    // Prints magic numbers which can be copied and used for move generation
    pub(crate) fn print_magic_numbers(&mut self) {
        println!("\nBishop magic numbers:");
        for square in Square::ALL_SQUARES {
            println!("0x{:x},", self.generate_magic_number(square, MoveMasks::get_bishop_relevant_bits(square), true));
        }

        println!("\nRook magic numbers:");
        for square in Square::ALL_SQUARES {
            println!("0x{:x},", self.generate_magic_number(square, MoveMasks::get_rook_relevant_bits(square), false));
        }
        
    }
}