Stavanger/MoveGenerator.h at main · JuliusVanderArend/Stavanger · GitHub

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
//
// Created by Julius on 03/03/2024.
//


#ifndef UNTITLED_MOVEGENERATOR_H
#define UNTITLED_MOVEGENERATOR_H

#include <array>
#include <vector>
#include "Position.h"
#include "Helper.h"

namespace Engine {
    struct magicEntry{
        int indexSize;
        uint64_t magic;

//        magicEntry(int s, uint64_t magic) : indexSize(s), magic(magic) {}
    };

    class MoveGenerator {
    public:
        MoveGenerator();
        std::vector<Move> generateMoves(Position* position);
        static bool squareIsAttacked(int square, Position* position);

    private:
        static const int MAX_MAGIC_BITS = 15;

//        inline void addMove(const std::vector<Move>& moves,const Position& position, uint8_t from, uint8_t to, uint8_t code, uint8_t capture = 0){
//            moves.emplace_back(to | (from<<6) | (code << 12) | (capture << 16));
//        }

        static Bitboard generateMagicMaskRay(int direction, int squareIndex);
        static Bitboard generateRookMagicMask(int squareIndex);
        static Bitboard generateBishopMagicMask(int squareIndex);
        static Bitboard floodFill(int direction,  int squareIndex, Bitboard blockers);
        static Bitboard floodfillRookAttacks(int position,Bitboard blockers);
        static Bitboard floodfillBishopAttacks(int position,Bitboard blockers);
        static Bitboard generateKnightAttacks(int squareIndex);
        static Bitboard generateKingAttacks(int squareIndex);
        static Bitboard generatePawnAttacks(int square, bool whiteToMove);

        static void directionToXYStep(int direction, int& stepX, int& stepY);

        static void generateAllBlockerConfigs(std::vector<Bitboard>& configs,Bitboard mask);

        static void initializeMagics();
        static int validateMagic(bool isBishop, int squareIndex, uint64_t magic);

        static std::vector<Move> attackMapToMoveset(Bitboard attackMap,Bitboard blockers, uint32_t squareIndex);

        static void generateMagicMoves(std::vector<Move>& moves,Position* position,Bitboard pieces, std::array<std::array<Bitboard,
                                1 << MAX_MAGIC_BITS>,64>& magicAttacks, std::array<Bitboard,64>& magicMasks, std::array<magicEntry,64> magics);
        static void generateKnightMoves(std::vector<Move>& moves,Position* position,Bitboard knights);
        static void generateKingMoves(std::vector<Move>& moves,Position* position,int square);
        static void generatePawnMoves(std::vector<Move>& moves,Position* position,Bitboard pawns);

        inline static std::array<magicEntry,64> rookMagics;
        inline static std::array<magicEntry,64> bishopMagics;

        inline static std::array<std::array<Bitboard,1 << MAX_MAGIC_BITS>,64> rookMagicAttacks;
        inline static std::array<std::array<Bitboard,1 << MAX_MAGIC_BITS>,64> bishopMagicAttacks; // can be smaller?
        inline static std::array<Bitboard,64> knightAttacks;
        inline static std::array<Bitboard,64> kingAttacks;
        inline static std::array<Bitboard,64> whitePawnAttacks;
        inline static std::array<Bitboard,64> blackPawnAttacks;

        inline static std::array<std::array<std::vector<Move>,1 << MAX_MAGIC_BITS>,64> rookMagicMovesets;
        inline static std::array<std::array<std::vector<Move>,1 << MAX_MAGIC_BITS>,64> bishopMagicMovesets;

        inline static std::array<Bitboard ,64> rookMagicMasks;
        inline static std::array<Bitboard ,64> bishopMagicMasks;
    };


} // Engine

#endif //UNTITLED_MOVEGENERATOR_H