public AlphaBetaReturnValue MinValue(CheckersBoard board, int alphaValue, int betaValue, PieceColor color, ref int currentDepth, ref int maxDepth, int maxDepthToSearchFor)
        {
            NodesGenerated++;

            var v = new AlphaBetaReturnValue(PositiveInfinity, null, currentDepth + 1);
            var moves = board.GetAllAvailableMoves(color).ToList().OrderByDescending(mr => mr.JumpResults.Count()).ToList();
            var coTest = CutoffTest(board, currentDepth, maxDepthToSearchFor);

            if (coTest.HasValue && coTest.Value || !moves.Any())
            {
                v.Value = Evaluate(board, color);
                v.Depth = currentDepth;

                return v;
            }
            if (!coTest.HasValue)
            {
                return null;
            }

            for (var i = 0; i < moves.Count; i++)
            {
                var m = moves[i];
                board.MovePiece(m, color);

                if (currentDepth == 0 && moves.Count == 1)
                {
                    v.Move = m;
                    v.Value = Evaluate(board, color);

                    board.RevertMove(m, color);
                    return v;
                }

                var newDepth = currentDepth;

                newDepth++;
                var retVal = MaxValue(board, alphaValue, betaValue,
                                  color == PieceColor.Black ? PieceColor.Red : PieceColor.Black, ref newDepth,
                                  ref maxDepth, maxDepthToSearchFor);

                if (retVal == null)
                    return null;

                retVal.Move = m;

                board.RevertMove(m, color);

                if (retVal.Depth > maxDepth)
                    maxDepth = retVal.Depth;

                if(retVal.Value < v.Value)
                {
                    v.Value = retVal.Value;
                    v.Move = retVal.Move;
                }

                if (v.Value <= alphaValue)
                {
                    NumberOfMinPrunes++;
                    return retVal;
                }

                betaValue = Math.Min(betaValue, v.Value);
            }

            return v;
        }