Iterative deepening made my bot worse

[2tothe4th]

I tried to add iterative deepening but it's preforming worse then a fixed depth of 4.

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, 0xBCCDABBBEEEEEEEE }, //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)
    {

        Square kingSqaure = board.GetKingSquare(white);

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

        float endgameWeight =
            1 - (Math.Clamp(BitboardHelper.GetNumberOfSetBits(board.AllPiecesBitboard), 8, 24) - 8) / 16;
        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] + 100 : 0) * endgameWeight;


            }
        }

        evaluation += (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) * endgameWeight * 10
            /*+ Math.Clamp((BitboardHelper.GetNumberOfSetBits(board.WhitePiecesBitboard) - BitboardHelper.GetNumberOfSetBits(board.BlackPiecesBitboard)) * (white ? 1 : -1), 0, 1) * 32 - board.AllPiecesBitboard*/
            + (board.GetPieceList(PieceType.Bishop, white).Count >= 2 ? 50 : 0)
            + ((white ? board.WhitePiecesBitboard : board.BlackPiecesBitboard) & (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)*/;

    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];
    Move bestMoveThisSearch;
    public int Search(Board board, Timer timer, int depth, int plyFromRoot, int alpha, int beta)
    {
        if (timer.MillisecondsElapsedThisTurn > 500)
            return 0;

        int oldAlpha = alpha;
        Move[] moves = board.GetLegalMoves();
        moves = moves.OrderByDescending(move => move.IsCapture ? getPieceValue(move.CapturePieceType) - getPieceValue(move.MovePieceType) + 50 : 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);
        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)
                    bestMoveThisSearch = 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)) ;
        bestMoveThisSearch = board.GetLegalMoves()[0];
        if (board.PlyCount == 0)
            return new Move(new[] { "e2e4", "d2d4", "g1f3" }[new Random().Next(3)], board);
        
        for (int i = 0; i < 384; i++)
            pieceSquareValues[i / 64, i % 64] = extractBonusSquare(i / 64, i % 64);
        
        int depth = 1;
        Move bestMove = Move.NullMove;
        while (timer.MillisecondsElapsedThisTurn <= 500)
        {
            bestMove = bestMoveThisSearch;
            Search(board, timer, depth, 0, -2147483647, 2147483647);
            depth++;
        }
        return bestMove;
    }
}

[jongdetim]

Why would it not make your bot slower? You're not using the previous search results to sort the moves.

[Edward-789]

Most likely. because you are not using TT move ordering, which saves the move into your entry, and sets that move as the first move to check, as its likely that the TT move from the previous entry is also good in your currentl position, despite other numbers being different

[jongdetim]

For some reason, my bot also performs worse when i use iterative deepening with PV move ordering, compared to vanilla a-b search... I've been trying to figure out why forever, but just can't figure it out....