Plan_Moves.txt

class Bitboard{
    ...
};

class ChessBoard{
    Chessboard(bitborad Pawns, ...)
    Chessboard(Chessboard currentChessBoard, Move MoveApplied)  //return kainouria Chessboard dedomenis mias kinisis, dld ton startIndex kai endIndex
                                                                //kai if an ginei capture

    array[Moves] getMoves{
        if (check) {
            ...
        }
        bb King_moves_legal();
        //apople3e, orise moves kai append to resultArray
        
        Bitboard [pins, pinners] = find_pins(); //see xRayAttacks
        for pins {
            
            //only move along the pin direction (easy since we have each pinner)     
        
        }
        for !pins { //NOT(XOR(White, pins))
        
            BitboardPawns -= pins;
            temp[Bitboard] = BitboardPawns.Generate_left_captures(current);
            for bb in temp:                             //apople3e, orise moves kai append to resultArray
                resultArray.add(  Move(Bitboard, )  )) 
            //etc
            revert this: BitboardPawns -= pins;
        
            ...
        
        } 
        
        


        return resultArray;
        //WHAT IS "changes required p.x. occupied"?

    }
};

class Move {
    public:
        Move(start,end,isCapture);
    protected:
        int startIndex;
        int endIndex;
        bool isCapture;
}

class Node{
    ...
    Chessboard c;
    moves = c.getMoves();
    for Move in moves:
        new Chessboard(c, Move);
        node.addChild();

    bool afterCapture; //

};

class BitboardPawns : Bitboard{
    Bitboard current;
    Bitboard Generate_left_captures(current){
        return new Bitboard with pawn position after Left Captures
    }
    Bitboard Generate_right_captures(current){
        return new Bitboard with pawn position after Right Captures
    }
    Bitboard Generate_front_moves(current){
        return new Bitboard with pawn position after front moves
    }
    Bitboard Generate_double_front_moves(current){
        return new Bitboard with pawn position after front moves
    }
    //ekkremei an passan
}

class Knights{
    Bitboard current;
    list[] extract_knights_index(current){
        return list of indexes of knights
    }
    Bitboard Generate_moves_from_index(index){
        return  precalculated moves given an index
    }
};

Same class for King ??

class Bishop{
    Bitboard current
    list[] extract_bishop_index(current){
        return list of indexes of knights
    }
    Bitboard Get_Blockers(current ChessBoard position, index)
        return Bitboard with 1 where blocker

    moves Generate_moves_from_index(index){
        return precalculated moves given an index
    }
};

Same for Rook, Queen