Определить бьют ли друг друга шахматные фигуры в заданной позиции

///////////////////////////////////////////////////////////////////////////////
//1.
///////////////////////////////////////////////////////////////////////////////
//Недавно Петя начал играть в шахматы.
//Напомним, что в шахматы играют два игрока, у каждого из которых
//изначально есть по 8 фигур и 8 пешек. В этой задаче пешки
//рассматривать не будем.
//Ни одна фигура, кроме коня, не может перепрыгивать через свои
//или чужие фигуры. Нельзя делать ход на поле, занятое своей фигурой.
//При ходе на поле, занятое чужой фигурой, она снимается с доски.
//Фигуры ходят следующим образом:
//- король — на любую соседнюю по вертикали, горизотнали или диагонали клетку;
//- ферзь - на любое расстояние по вертикали, горизотнали или диагонали;
//- ладья - на любое расстояние по вертикали, горизотнали;
//- слон - на любое расстояние по диагонали;
//- конь - в форме буквы «Г»: на 1 клетку по горизонтали и на 2 по вертикали,
//или наоборот, на 1 клетку по вертикали и 2 по горизонтали.
//Вам даны позиции одной белой и одной черной фигуры. Определите,
//бьют ли фигуры друг друга, и, если бьют, выведите какая из них бьет какую.
 
//Формат входного файла
//Первая строка входного файла содержит тип и позицию белой фигуры.
//Вторая строка содержит тип и позицию черной фигуры.
//Каждая фигура задается строкой, состоящей из трех символов.
//Первый символ обозначает тип фигуры:
//    «В» — слон,
//    «N» — конь,
//    «R» — ладья,
//    «Q» — ферзь,
//    «К» — король.
//Второй символ задает горизонталь (от «а» до «h»).
//Третий символ задает вертикаль (от «1» до «8»).
 
//Гарантируется, что фигуры стоят на различных клетках шахматной доски.
 
//Формат выходного файла
//В выходной файл выведите одно слово — ответ на задачу.
//В случае, если ни одна фигура не бьет другую, выведите «NONE».
//В случае, если обе фигуры бьют друг друга, выведите «ВОТН».
//В случае, если белая фигура бьет черную, а черная не бьет белую,
//выведите «WHITE». В случае, если черная фигура бьет белую,
//а белая не бьет черную, выведите «BLACK».
///////////////////////////////////////////////////////////////////////////////
#include <cmath>
#include <iostream>
///////////////////////////////////////////////////////////////////////////////
enum    T_piece_type
{
    BISHOP_PIECE    =   'B',
    KNIGHT_PIECE    =   'N',
    ROOK_PIECE      =   'R',
    QUEEN_PIECE     =   'Q',
    KING_PIECE      =   'K'
};
///////////////////////////////////////////////////////////////////////////////
struct  T_piece
{
    //-------------------------------------------------------------------------
    T_piece_type    piece_type_;
    char            col_;
    char            row_;
    //-------------------------------------------------------------------------
    bool    attacks( T_piece    const   &   p )                             const
    {
        int     abs_delta_col   =   std::abs( col_ - p.col_ );
        int     abs_delta_row   =   std::abs( row_ - p.row_ );
 
        switch( piece_type_ )
        {
        case    BISHOP_PIECE    :   return  bishop_attacks  ( abs_delta_col,  abs_delta_row );
        case    KNIGHT_PIECE    :   return  knight_attacks  ( abs_delta_col,  abs_delta_row );
        case    ROOK_PIECE      :   return  rook_attacks    ( abs_delta_col,  abs_delta_row );
 
        case    QUEEN_PIECE     :   return  queen_attacks   ( abs_delta_col,  abs_delta_row );
        case    KING_PIECE      :   return  king_attacks    ( abs_delta_col,  abs_delta_row );
        default                 :   return  false;
        }
    }
    //-------------------------------------------------------------------------
    static
    bool    bishop_attacks
        (
            int     abs_delta_col,
            int     abs_delta_row
        )
    {
        return      abs_delta_col
                ==  abs_delta_row;
    }
    //-------------------------------------------------------------------------
    static
    bool    rook_attacks
        (
            int     abs_delta_col,
            int     abs_delta_row
        )
    {
        return          abs_delta_col
                    *   abs_delta_row
                ==  0;
    }
    //-------------------------------------------------------------------------
    static
    bool    knight_attacks
        (
            int     abs_delta_col,
            int     abs_delta_row
        )
    {
        return          abs_delta_col
                    *   abs_delta_row
                ==  2;
    }
    //-------------------------------------------------------------------------
    static
    bool    queen_attacks
        (
            int     abs_delta_col,
            int     abs_delta_row
        )
    {
        return      bishop_attacks  ( abs_delta_col,  abs_delta_row )
                ||  rook_attacks    ( abs_delta_col,  abs_delta_row );
    }
    //-------------------------------------------------------------------------
    static
    bool    king_attacks
        (
            int     abs_delta_col,
            int     abs_delta_row
        )
    {
        return      queen_attacks   ( abs_delta_col,  abs_delta_row )
                &&  std::max        ( abs_delta_col,  abs_delta_row )   ==  1;
    }
    //-------------------------------------------------------------------------
};
///////////////////////////////////////////////////////////////////////////////
std::istream    &   operator>>
    (
        std::istream    &   istr,
        T_piece         &   piece
 
    )
{
    char    piece_type_symb{};
 
    istr    >>  piece_type_symb
            >>  piece.col_
            >>  piece.row_;
 
    piece.piece_type_   =   T_piece_type( piece_type_symb );
    return  istr;
}
///////////////////////////////////////////////////////////////////////////////
int     main()
{
    T_piece     white_piece;
    T_piece     black_piece;
 
    std::cin    >>  white_piece
                >>  black_piece;
 
    std::cout   <<  (
                        white_piece.attacks             ( black_piece )
                            ?   black_piece.attacks     ( white_piece )
                                    ?   "BOTH"
                                    :   "WHITE"
 
                            :   black_piece.attacks     ( white_piece )
                                    ?   "BLACK"
                                    :   "NONE"
                    )
 
                <<  std::endl;
}