Weird Sacrifices

[2tothe4th]

So my bot is pretty good, but it makes random sacrifices when it can clearly save the piece. For example, if you play the bot against itself, it will just randomly put the pawns in the center just for it to get taken.

using System;
using System.Linq;
using ChessChallenge.API;

public class MyBot : IChessBot
{
    //From https://www.chessprogramming.org/Simplified_Evaluation_Function#Piece-Square_Tables
    ulong[,] packedTables = {
            { 0x0000888822461121, 0x000419A0122B0000 }, //pawn
            { 0xEDCCDB00C043C132, 0xC032C143DB01EDCC }, //knight
            { 0xBAAAA000A012A112, 0xA042A222A100BAAA }, //bishop
            { 0x0000122290009000, 0x9000900090000001 }, //rook
            { 0xBAA9A000A0119011, 0x0011A111A010BAA9 }, //queen
            { 0xCDDECDDECDDECDDE, 0xBCCDABBB4400EEEE }, //king
        };
    int[] pieceValues = { 0, 100, 300, 320, 500, 900, 0 };

    int getPieceValue(PieceType piece) =>
            pieceValues[(int)piece];

    int extractBonusSquare(int table, int index)
    {
        if (table == 5 && index / 8 == 7)
        {
            if (index % 8 == 2 || index % 8 == 6)
                return 30;
            else if (index % 8 == 4)
                return 0;
        }
        int[] bonusValues = { 0, 5, 10, 15, 20, 25, 30, 40, 50, -5, -10, -20, -30, -40, -50 };
        int offset = index / 8 * 4 + ((index & 7) ^ ((index & 7) > 3 ? 0b111 : 0));
        return bonusValues[packedTables[table, index / 32] << (offset % 16 * 4) >> 60];
    }

    ulong fileMask = 0x0101010101010101;
    ulong getPawnMask(Square square, bool white) => fileMask << square.File + square.Rank * 8 * (white ? 1 : -1);
    int calculateDistanceFromSquare(Square square1, Square square2) => Math.Abs(square1.Rank - square2.Rank) + Math.Abs(square1.File - square2.File);
    public int EvaluateOneSide(Board board, bool white)
    {
        ulong bitboard = white ? board.WhitePiecesBitboard : board.BlackPiecesBitboard;

        Square kingSqaure = board.GetKingSquare(white);
        int mopUpScore = Math.Min(
            Math.Min(calculateDistanceFromSquare(kingSqaure, new Square(0))
            , calculateDistanceFromSquare(kingSqaure, new Square(7))),
            Math.Min(calculateDistanceFromSquare(kingSqaure, new Square(56))
            , calculateDistanceFromSquare(kingSqaure, new Square(63)))) - 6;

        //ulong pieceBitboard = board.WhitePiecesBitboard | board.BlackPiecesBitboard;

        float endgameWeight =
            1 - (Math.Clamp(BitboardHelper.GetNumberOfSetBits(board.WhitePiecesBitboard | board.BlackPiecesBitboard), 8, 24) - 8) / 4;
        float evaluation = 0;

        Square enemyKingSquare = board.GetKingSquare(!white);
        for (int i = 0; i < 6; i++)
        {
            foreach (Piece currentPiece in board.GetAllPieceLists()[i + (white ? 0 : 6)])
            {
                Square currentSqaure = currentPiece.Square;
                int[] endgamePawnBonusValues = { 0, -2, -2, 1, 2, 5, 8, 0 };
                int squareIndex = currentPiece.Square.Index ^ (white ? 0b111000 : 0);
                evaluation += getPieceValue(currentPiece.PieceType)
                    + (currentPiece.IsPawn || currentPiece.IsKing ? (1 - endgameWeight) : 1)
                    * pieceSquareValues[(int)currentPiece.PieceType - 1, squareIndex]
                    + (currentPiece.IsPawn && endgameWeight != 0 ? BitboardHelper.GetNumberOfSetBits(getPawnMask(currentSqaure, white) & BitboardHelper.GetKingAttacks(kingSqaure)) 
                    + endgamePawnBonusValues[7 - squareIndex / 8] : 0) * endgameWeight;


            }
        }

        evaluation += mopUpScore * endgameWeight * 10
            + (board.GetPieceList(PieceType.Bishop, white).Count >= 2 ? 50 : 0)
            + (bitboard & (fileMask << kingSqaure.File)) == 0 ? 50 * (1 - endgameWeight) : 0
            + calculateDistanceFromSquare(kingSqaure, enemyKingSquare) * 25 * endgameWeight;
        return (int)evaluation;

    }

    //List<Move> killerMoves = new List<Move>();
    //int scoreMove(Move move) => (move.IsCapture ? getPieceValue(move.CapturePieceType) - getPieceValue(move.MovePieceType) : 0)/* + (!move.IsCapture && killerMoves.Contains(move) ? 50 : 0)/* + (move.IsCastles ? 10 : 0)*/;
    Move bestMove;

    public struct Transposition
    {
        public ulong zobristHash = 0;
        public int evaluation, depth, flag = 0;
        //1: UPPERBOUND
        //0: EXACT
        //-1: LOWERBOUND
        //-2: INVALID

        public Transposition(ulong zHash, int eval, int d, int f)
        {
            zobristHash = zHash;
            evaluation = eval;
            depth = d;
            flag = f;
        }
    };

    ulong TTMask = 0x7FFFFFF;
    Transposition[] transpositionTable = new Transposition[0x8000000];
    //This code was from "Algorithms Explained – minimax and alpha-beta pruning" by Sebastian Lague
    //https://en.wikipedia.org/wiki/Negamax
    int[,] pieceSquareValues = new int[6, 64];
    public int Search(Board board, Timer timer, int depth, int plyFromRoot, int alpha, int beta)
    {
        int oldAlpha = alpha;
        Move[] moves = board.GetLegalMoves();
        moves = moves.OrderByDescending(move => move.IsCapture ? getPieceValue(move.CapturePieceType) - getPieceValue(move.MovePieceType) : 0).ToArray();

        if (board.IsInCheckmate())
            return -2147483647 + plyFromRoot;
        else if (board.IsDraw())
            return 0;
        
        Transposition TTEntry = transpositionTable[board.ZobristKey & TTMask];
        if (TTEntry.zobristHash == board.ZobristKey && TTEntry.depth >= depth)
        {
            switch (TTEntry.flag)
            {
                case -2:
                    break;
                case 0:
                    return TTEntry.evaluation;
                case -1:
                    alpha = Math.Max(alpha, TTEntry.evaluation);
                    break;
                case 1:
                    beta = Math.Min(beta, TTEntry.evaluation);
                    break;
            }
            if (beta <= alpha)
                return TTEntry.evaluation;
        }
        if (depth == 0)
            return (EvaluateOneSide(board, true) - EvaluateOneSide(board, false)) * (board.IsWhiteToMove ? 1 : -1);
        if (plyFromRoot == 0)
            bestMove = moves[0];
        int bestEval = -2147483647;
        foreach (Move currentMove in moves)
        {
            board.MakeMove(currentMove);
            int evaluation = -Search(board, timer, depth - 1, plyFromRoot + 1, -beta, -alpha);
            board.UndoMove(currentMove);

            if (evaluation > bestEval)
            {
                bestEval = evaluation;
                if (plyFromRoot == 0)
                    bestMove = currentMove;
            }

            alpha = Math.Max(alpha, bestEval);

            if (beta <= alpha)
            {
                //if (!currentMove.IsCapture)
                //killerMoves.Add(currentMove);
                break;
            }
        }
        transpositionTable[board.ZobristKey & TTMask] = new Transposition(board.ZobristKey, bestEval, depth,
            bestEval <= oldAlpha ? 1 : bestEval >= beta ? -1 : 0);
        return bestEval;
    }
    public Move Think(Board board, Timer timer)
    {
        //BitboardHelper.VisualizeBitboard(getPawnMask(board.GetPieceList(PieceType.Pawn, true)[0].Square, true)) ;
        for (int i = 0; i < 384; i++)
            pieceSquareValues[i / 64, i % 64] = extractBonusSquare(i / 64, i % 64);
        Console.WriteLine("Eval: " + Search(board, timer, 4, 0, -2147483647, 2147483647) * (board.IsWhiteToMove ? 1 : -1));
       
        return bestMove;
    }
}

[ryanheath]

You should probably look into Quiescence Search