NegaScout com mesas de transposição Zobrist no xadrez

Estou tentando colocar tabelas de transposição no meu escoteiro alfa beta. Eu vejo um aumento de velocidade incremental, acho que no meio ou no final do jogo, no entanto, mesmo com um tamanho de mesa de 1-2 GB, pode ou não ser mais lento do que simplesmente não ler a tabela Transpose. Também estou percebendo alguns movimentos menos eficientes se eu jogar exatamente o mesmo jogo sem as mesas.

Testei meu hash de chave Zobrist, e eles saem corretamente mesmo depois de fazer e desfazer movimentos. Eu não acredito que eles sejam o problema. Tentei seguir o conselho desses artigos ao projetar a poda alfa / beta. http://web.archive.org/web/20070809015843/http://www.seanet.com/~brucemo/topics/hashing.htm http://mediocrechess.blogspot.com/2007/01/guide-transposition- tables.html

Alguém pode me ajudar a identificar um erro? Talvez eu não esteja entendendo a avaliação da verificação de alfa x beta do hash. Ou 1-2 GB é pequeno demais para fazer a diferença? Posso postar mais do código da tabela de transposição, se necessário.

 public int alphaBetaScout(Board board, int depth, int alpha, int beta, bool color, bool 
quiscence)
{
    // !!!! With or without this specific section, and any other Transpose.Insert, doesn't make the game play or evaluate any faster.
    HashType type = HashType.AlphaPrune;
    HashEntry h = Transpose.GetInstance().Get(board.zobristKey);
    if (h != null)
    {
        if (h.depth >= depth)
        {
            if (h.flag == HashType.ExactPrune)
            {
                return h.scored;
            }
            if (h.flag == HashType.AlphaPrune)
            {
                if(h.scoredState > alpha)
                {
                    alpha = h.scored;
                }
            }
            if (h.flag == HashType.BetaPrune)
            {
                if(h.scoredState < beta)
                {
                    beta = h.scored;
                }
            }
            if (alpha >= beta)
            {
                return alpha;
            }
        }
    }

    if (board.terminal)
    {
        int scoredState = board.Evaluate(color);
        Table.GetInstance().Add(board.zobristKey, depth, Entry.EXACT, scoredState);
        return scoredState;
    }

    //May do Quescience search here if necessary && depth = 0

    Stack movesGenerated = GeneratePossibleMoves();
    while(!movesGenerated.isEmpty())
    {
        int scoredState = MAXNEGASCOUT;

        board.MakeMove(movesGenerated.pop());
        int newAlpha = -(alpha +1)
        scoredState = -alphaBetaScout(board, depth - 1, newAlpha, -alpha, !color, quiscence);

        if (scoredState < beta && alpha < scoredState)
        {
            scoredState = -alphaBetaScout(board, depth - 1, -beta, -scoredState, !color, quiscence);
        }

        board.UndoMove();

        if (scoredState >= beta)
        {
            Table.GetInstance().Add(key, depth, Entry.BETA, beta);
            return scoredState;
        }

        if (scoredState > alpha)
        {
            type = HashType.ExactPrune;
            alpha = scoredState;
        }
    }
    Table.GetInstance().Add(key, depth, type, alpha);
    return alpha;
}

O código parece bom à primeira vista. Eu sugeriria criar um perfil da tabela de transposição, talvez sua implementação real seja apenas lenta para armazenar e recuperar as entradas. O que também explicaria por que você obtém melhores movimentos com transposições, embora não obtenha um benefício de velocidade.

Não insira na tabela de transposição no nó da folha.

Portanto, comente o comando "Adicionar" neste bloco "if (board.terminal)"