Алгоритм поиска всех возможных комбинаций взятий дамкой в русских шашках

#include <iostream>
#include <optional>
#include <algorithm>
 
#include "Board.hpp"
#include "Position.hpp"
#include "Checker.hpp"
#include "Combination.hpp"
 
std::vector<Combination> allCombinations;
Combination combination;
 
// Проверка наличия позиции в цепочке взятий
bool containsCapture(const Combination& comb, const Position& pos)
{
    return std::find(std::cbegin(comb.capturedPositions()), std::cend(comb.capturedPositions()), pos) != std::cend(comb.capturedPositions());
}
 
// Поиск позиции взятия в заданном направлении
std::optional<Position> findJump(const Board& board, const Position& startPosition, Direction direction)
{
    Position position = startPosition.next(direction);
    while (position.onBoard() && board.isEmpty(position))
        position = position.next(direction);
 
    if (position.onBoard() && position.next(direction).onBoard() &&
        !board.isEmpty(position) && board.isEmpty(position.next(direction)) &&
        board.checker(position).color() != board.checker(startPosition).color())
        return position;
    else
        return {};
}
 
void findCombination(Board& board, Position startPosition, Direction direction);
 
// Поиск комбинацйи по всем направлениям
void findAllPossibleCombinations(Board& board, Position startPosition)
{
    for (Direction direction : DirectionsArray)
        findCombination(board, startPosition, direction);
}
 
void findCombination(Board& board, Position startPosition, Direction direction)
{
    auto capturedPosition = findJump(board, startPosition, direction);
    if (capturedPosition.has_value() && !containsCapture(combination, *capturedPosition))
    {
        combination.pushCapturedPosition(*capturedPosition, direction);
 
        Checker checker = board.checker(startPosition);
 
        board.remove(startPosition);
        for (Position position = capturedPosition->next(direction); position.onBoard() && board.isEmpty(position); position = position.next(direction))
        {
            board.set(position, checker);
            findAllPossibleCombinations(board, position);   
            board.remove(position);
        }
        board.set(startPosition, checker);
    }
    else if (!combination.capturedPositions().empty())
    {
        allCombinations.push_back(combination);
        combination.removeCapturedPosition();
    }
}
 
int main()
{
    Board board;
    board.set(Position{1, 1}, Checker{Color::White});
    board.set(Position{3, 3}, Checker{Color::White});
    board.set(Position{5, 5}, Checker{Color::Black});
    // board.set(Position{3, 5}, Checker{Color::White});
    // board.set(Position{5, 3}, Checker{Color::White});
    // board.set(Position{7, 5}, Checker{Color::White});
    // board.set(Position{7, 1}, Checker{Color::Black});
 
    findAllPossibleCombinations(board, Position{5, 5});
 
    std::cout << allCombinations.size() << std::endl;
 
    for (const auto& comb : allCombinations)
    {
        for (const auto& pos : comb.capturedPositions())
        {
            std::cout << "[" << (int)pos.row << " ; " << (int)pos.col << "]" << " ";
        }
        std::cout << std::endl;
    }
}