Определить все ходы для белой шашки.

//На шашечном поле в произвольном порядке расставлены шашки. 
//Для выбранной пользователем белой шашки определить все ее возможные ходы. 
//Учесть, что за один шаг белая шашка может сбить несколько черных шашек.
//Нужно использовать рекурсию.
#include <iostream>
#include <vector>
#include <string>
#include <map>
#include <algorithm>
 
const int VERT_MIN_VAL = 'a';
const int VERT_MAX_VAL = 'h';
 
const int HORIS_MIN_VAL = '1';
const int HORIS_MAX_VAL = '8';
 
typedef std::string  T_str;
 
enum T_shashka_color
{
    VNE_DOSKI = 0,
    EMPTY,
    WHITE,
    BLACK    
};
 
enum T_napravl
{
    VLEVO,
    VPRAVO,
    NAZAD_VLEVO,
    NAZAD_VPRAVO
};
 
typedef std::map<char, T_shashka_color>  T_doska_vert;
typedef std::map<char, T_doska_vert>     T_shashka_colors;
 
struct T_kletka
{
    char  vert_; //От 'a' до 'h'.   
    char  horis_;//От '1' до '8'.
    
    T_kletka(char  vert = 0, char  horis = 0) : vert_(vert), horis_(horis)
    {}
 
    T_kletka(T_str  str_coord) 
        : vert_(str_coord[0]), horis_(str_coord[1])        
    {}
 
    T_kletka  get_next_1(T_napravl  napravl)
    {
        int  vert_shift   = 0;
        int  horis_shift  = 0;
 
        switch(napravl)
        {
        case VLEVO: 
            vert_shift   = -1;
            horis_shift  =  1;
            break;
        case VPRAVO: 
            vert_shift   = 1;
            horis_shift  = 1;
            break;
        case NAZAD_VLEVO: 
            vert_shift   = -1;
            horis_shift  = -1;
            break;
        case NAZAD_VPRAVO: 
            vert_shift   =  1;
            horis_shift  = -1;
            break;
        default:
            ;           
        }//switch(napravl)
        return T_kletka(vert_ + vert_shift, horis_ + horis_shift);
    }
};//struct T_kletka
 
void  print_kletka(T_kletka  kletka)
{        
    std::cout << kletka.vert_ << kletka.horis_ << ' ';   
}
 
typedef std::vector<T_kletka>  T_path;
 
class T_doska
{
    T_shashka_colors  shashka_colors;
public:
    T_doska()
    {
        for(char vert = VERT_MIN_VAL; vert <= VERT_MAX_VAL; ++vert)
        {
            for(char horis = HORIS_MIN_VAL; horis <= HORIS_MAX_VAL; ++horis)
            {
                shashka_colors[vert][horis] = EMPTY;
            }
        }
    }
 
    bool  is_emty_kletka(T_kletka  kletka)
    {
        return get_shashka_color_ref(kletka) == EMPTY;
    }
 
    void swap_colors
        (
            T_kletka  kletka1,
            T_kletka  kletka2
        )
    {
        T_shashka_color&  color1 = get_shashka_color_ref(kletka1);
        T_shashka_color&  color2 = get_shashka_color_ref(kletka2);
        std::swap(color1, color2);
    }
 
    bool  are_raznocvetn_shashki
        (
            T_kletka  kletka1,
            T_kletka  kletka2
        )
    {
        T_shashka_color  color1 = get_shashka_color_ref(kletka1);
        T_shashka_color  color2 = get_shashka_color_ref(kletka2);
        return    color1 == WHITE && color2 == BLACK
               || color1 == BLACK && color2 == WHITE;       
    }
 
    void  del_shashka(T_kletka  kletka)
    {
        get_shashka_color_ref(kletka) = EMPTY;
    }
 
    void  set_white_shashka(T_kletka  kletka)
    {
        get_shashka_color_ref(kletka) = WHITE;
    }
 
    void  set_black_shashka(T_kletka  kletka)
    {
        get_shashka_color_ref(kletka) = BLACK;
    }
private:
    T_shashka_color&  get_shashka_color_ref(T_kletka  kletka)
    {
        return shashka_colors[kletka.vert_][kletka.horis_];    
    }
};//class T_doska
 
struct T_shashka
{
    void xod
        (            
            T_kletka  kletka,
            T_doska   doska
        )
    {
        T_path  path;
        path.push_back(kletka);       
        xod(VLEVO,  path, doska);
        xod(VPRAVO, path, doska);      
        
        bit(VLEVO,        path, doska);
        bit(VPRAVO,       path, doska);
        bit(NAZAD_VLEVO,  path, doska);
        bit(NAZAD_VPRAVO, path, doska);        
    }
 
    void xod
        (
            T_napravl  napravl,
            T_path     path,
            T_doska    doska
        )
    {        
        T_kletka  cur_kletka   = path.back();
        T_kletka  next_kletka  = cur_kletka.get_next_1(napravl);
        if(doska.is_emty_kletka(next_kletka))
        {                        
            doska.swap_colors(cur_kletka, next_kletka);
            path.push_back(next_kletka);
            print_path(path);            
        }     
    }
 
    void  bit
        (
            T_napravl  napravl,            
            T_path     path,
            T_doska    doska
        )
    {        
        T_kletka  cur_kletka   = path.back();
        T_kletka  next_kletka1 = cur_kletka   .get_next_1(napravl);
        T_kletka  next_kletka2 = next_kletka1 .get_next_1(napravl);
 
        if(doska.are_raznocvetn_shashki(cur_kletka, next_kletka1)
           && doska.is_emty_kletka(next_kletka2))
        {
            doska.swap_colors(cur_kletka, next_kletka2);            
            doska.del_shashka(next_kletka1);         
            path.push_back(next_kletka2);
 
            bit(VLEVO,        path, doska);
            bit(VPRAVO,       path, doska);
            bit(NAZAD_VLEVO,  path, doska);
            bit(NAZAD_VPRAVO, path, doska);
            print_path(path);                           
        }        
    }
 
    void  print_path(const T_path&  path)
    {
        static int xod_count = 0;
        std::cout << "ход " << ++xod_count << ":   ";
        std::for_each(path.begin(), path.end(), print_kletka);
        std::cout << std::endl;    
    }
};//struct T_shashka
 
bool is_correct_str_coord(T_str  str_coord)
{
     return    VERT_MIN_VAL <= str_coord[0]  && str_coord[0] <= VERT_MAX_VAL
            && HORIS_MIN_VAL <= str_coord[1] && str_coord[1] <= HORIS_MAX_VAL;   
}
 
int main()
{   
    std::locale::global(std::locale("rus"));   
    std::cout << "Введите координаты шашек в виде a1, c3, f8 и т.д. "
              << std::endl
              << "Окончание ввода - пустая строка."
              << std::endl;
 
    T_doska  doska;    
    T_str    bel_xodit_str_coord;
    for(;;)
    {
        std::cout << "Координаты белой шашки, делающей ход: ";        
        getline(std::cin, bel_xodit_str_coord);    
        if(bel_xodit_str_coord.empty()) return 0;
        if(is_correct_str_coord(bel_xodit_str_coord))
        {           
            doska.set_white_shashka(bel_xodit_str_coord);
            break;
        }
    }
 
    for(int vvodim_chernye = 0; vvodim_chernye < 2; ++vvodim_chernye)
    {
         std::cout << std::endl
                  << "Введите координаты "
                  << (vvodim_chernye ? "черных" : "белых")
                  << " шашек: "
                  << std::endl;        
 
        for(int i = 1;;)
        {
            std::cout << (vvodim_chernye ? "черная " : "белая ")
                      << i
                      << ": ";
            
            T_str  cur_shash_str_coord;
            getline(std::cin, cur_shash_str_coord);
            if(cur_shash_str_coord.empty()) break;        
            if(is_correct_str_coord(cur_shash_str_coord))
            {        
                vvodim_chernye ? doska.set_black_shashka(cur_shash_str_coord)
                               : doska.set_white_shashka(cur_shash_str_coord);
                ++i;
            }        
        }   
    }//for(bool vvodim_chernye = false; vvodim_chernye <= true; ++vvodim_chernye)
 
    std::cout << std::endl;
    T_shashka  bel_xodit_shash;    
    bel_xodit_shash.xod(bel_xodit_str_coord, doska);  
 
    return 0;
}