MiniMax Algorithm with Chess in C# not working properly

Question

I've been trying to implement minimax algorithm in my C# chess engine for a week now and it makes legal moves but not meaningful moves. I cannot find the error, hopefully someone can spot it. I have tried to isolate the problem by testing each method and they all seem to work correctly except minimax.

public enum Piece
{
    Empty, Pawn_W, Pawn_B, Knight_W, Knight_B,
    Bishop_W, Bishop_B, Rook_W, Rook_B,
    Queen_W, Queen_B, King_W, King_B
}

public bool IsPieceWhite(Piece piece)
{
    if (piece == Piece.Pawn_W || piece == Piece.Knight_W ||
        piece == Piece.Bishop_W || piece == Piece.Rook_W ||
        piece == Piece.Queen_W || piece == Piece.King_W)
        return true;
    else return false;
}

public bool IsPieceBlack(Piece piece)
{
    if (piece == Piece.Pawn_B || piece == Piece.Knight_B ||
        piece == Piece.Bishop_B || piece == Piece.Rook_B ||
        piece == Piece.Queen_B || piece == Piece.King_B)
        return true;
    else return false;
}

public int GetPieceWorth(Piece piece)
{
    if (piece == Piece.Pawn_W || piece == Piece.Pawn_B)
        return 1;
    if (piece == Piece.Knight_W || piece == Piece.Knight_B)
        return 3;
    if (piece == Piece.Bishop_W || piece == Piece.Bishop_B)
        return 3;
    if (piece == Piece.Rook_W || piece == Piece.Rook_B)
        return 5;
    if (piece == Piece.Queen_W || piece == Piece.Queen_B)
        return 9;
    if (piece == Piece.King_W || piece == Piece.King_B)
        return 9999999;

    return 0;
}
Piece[,] CurrentBoard = GetStartingBoard();
Piece[,] bestMove;
public int depthB = 3;

public double minimax(Piece[,] board, int depth, bool maximizingPlayer)
{
    if (depth == 0)
    {
        double result = EvaluatePosition(board, maximizingPlayer);
        return result;
    }

    if (maximizingPlayer)
    {
        double best = Double.MinValue;
        double value = Double.MinValue;
        foreach (var move in GenerateMoves(board, maximizingPlayer))
        {
            Piece[,] clonedMove = CloneBoard(move);
            value = Math.Max(value, minimax(clonedMove, depth - 1, false));
            if (depth == depthB && value >= best)
            {
                best = value;
                bestMove = clonedMove;
            }
        }
        return value;
    }
    else
    {
        double best = Double.MaxValue;
        double value = Double.MaxValue;
        foreach (var move in GenerateMoves(board, maximizingPlayer))
        {
            Piece[,] clonedMove = CloneBoard(move);
            value = Math.Min(value, minimax(clonedMove, depth - 1, true));
            if (depth == depthB && value <= best)
            {
                best = value;
                bestMove = clonedMove;
            }
        }
        return value;
    }
}

public Piece[,] CloneBoard(Piece[,] boardPos)
{
    Piece[,] copy = boardPos.Clone() as Piece[,];
    return copy;
}

public double EvaluatePosition(Piece[,] boardPos, bool ForWhite)
{
    double eval = 0;
    for (int i = 0; i < 8; i++)
    {
        for (int j = 0; j < 8; j++)
        {
            if (boardPos[i, j] != Piece.Empty)
            {
                if (IsPieceWhite(boardPos[i, j]))
                {
                    eval += GetPieceWorth(boardPos[i, j]);
                }
                else if (IsPieceBlack(boardPos[i, j]))
                {
                    eval -= GetPieceWorth(boardPos[i, j]);
                }
            }
        }
    }

    if (ForWhite)
        return eval;
    else
        return eval * -1;
}

//a-h,0-7
//Piece[,] board = new Piece[8, 8];

public static Piece[,] GetStartingBoard()
{
    Piece[,] board = new Piece[8, 8];
    for (int i = 0; i < 8; i++)
    {
        //initiate pawns
        board[1, i] = Piece.Pawn_W;
        board[6, i] = Piece.Pawn_B;
    }

    //white pieces
    board[0, 0] = Piece.Rook_W;
    board[0, 1] = Piece.Knight_W;
    board[0, 2] = Piece.Bishop_W;
    board[0, 3] = Piece.Queen_W;
    board[0, 4] = Piece.King_W;
    board[0, 5] = Piece.Bishop_W;
    board[0, 6] = Piece.Knight_W;
    board[0, 7] = Piece.Rook_W;

    //black pieces
    board[7, 0] = Piece.Rook_B;
    board[7, 1] = Piece.Knight_B;
    board[7, 2] = Piece.Bishop_B;
    board[7, 3] = Piece.Queen_B;
    board[7, 4] = Piece.King_B;
    board[7, 5] = Piece.Bishop_B;
    board[7, 6] = Piece.Knight_B;
    board[7, 7] = Piece.Rook_B;

    //test
    //board[1, 4] = Piece.Pawn_B;
    //board[6, 2] = Piece.Pawn_W;

    return board;
}

I have uploaded a short clip of the engine playing against itself, to show the wierd moves: https://www.youtube.com/watch?v=A0HVgXYSciY

Answer 1

Finally was able to make the minimax function work. Thanks for all the help!

Working method:

        public int minimax(Piece[,] board, int depth, bool maximizingPlayer, bool WhiteToPlay)
        {
            if (depth == 0)
            {
                int result = EvaluatePosition(board, WhiteToPlay);
                return result;
            }

            var moves = GenerateMoves(board, WhiteToPlay);
            if (maximizingPlayer)
            {
                int value = int.MinValue;
                foreach (var move in moves)
                {
                    int minmaxResult = minimax(move, depth - 1, false, !WhiteToPlay);
                    value = Math.Max(value, minmaxResult);
                    if (depth == depthB)
                    {
                        moveScores.Add(move, minmaxResult);
                    }
                }
                return value;
            }
            else
            {
                int value = int.MaxValue;
                foreach (var move in moves)
                {
                    int minmaxResult = minimax(move, depth - 1, true, !WhiteToPlay);
                    value = Math.Min(value, minmaxResult);
                    if (depth == depthB)
                    {
                        moveScores.Add(move, minmaxResult);
                    }
                }
                return value;
            }
        }