Bot making very bad moves

[2tothe4th]

This is the code for my bot so far

using System;
using System.Linq;
using System.Collections.Generic;
using ChessChallenge.API;

public class MyBot : IChessBot
{
    //int positions = 0;
    //From https://www.chessprogramming.org/Simplified_Evaluation_Function#Piece-Square_Tables
    ulong[,] packedTables = {
            { 0x0000000088888888, 0x2246642211211211, 0x0004400019A00A91, 0x122BB22100000000 },
            { 0xEDCCCCDEDB0000BD, 0xC023320CC134431C, 0xC034430CC123321C, 0xDB0110BDEDCCCCDE },
            { 0xBAAAAAABA000000A, 0xA012210AA112211A, 0xA022220AA222222A, 0xA100001ABAAAAAAB },
            { 0x0000000012222221, 0x9000000990000009, 0x9000000990000009, 0x900000090A0110A0 },
            { 0xBAA99AABA000000A, 0xA011110A90111109, 0x00111109A111110A, 0xA010000ABAA99AAB },
            { 0xCDDEEDDCCDDEEDDC, 0xCDDEEDDCCDDEEDDC, 0xBCCDDCCBABBBBBBA, 0x4400004442600264 },
            { 0xEDCBBCDECBA00ABC, 0xCA4664ACCA6776AC, 0xCA6776ACCA4664AC, 0xCC0000CCECCCCCCE },
            { 0x0000000088888888, 0x7777777766666666, 0x55555555AAAAAAAA, 0xBBBBBBBB00000000 }
            //{ 0x10, 0x10 },

        };

    int extractBonusSqaure(int table, int index)
    {
        int[] bonusValues = { 0, 5, 10, 15, 20, 25, 30, 40, 50, -5, -10, -20, -30, -40, -50 };
        ulong mask = 0xF000000000000000 >> (index % 16) * 4;
        ulong currentSubTable = packedTables[table, index / 16];

        return bonusValues[(currentSubTable & mask) >> (15 - (index % 16)) * 4];
    }
    public int Evaluate(Board board, Timer timer)
    {
        int whiteMaterial =
                board.GetPieceList(PieceType.Pawn, true).Count
                + board.GetPieceList(PieceType.Knight, true).Count * 3
                + board.GetPieceList(PieceType.Bishop, true).Count * 3
                + board.GetPieceList(PieceType.Rook, true).Count * 5
                + board.GetPieceList(PieceType.Queen, true).Count * 9;

        int blackMaterial =
                board.GetPieceList(PieceType.Pawn, false).Count
                + board.GetPieceList(PieceType.Knight, false).Count * 3
                + board.GetPieceList(PieceType.Bishop, false).Count * 3
                + board.GetPieceList(PieceType.Rook, false).Count * 5
                + board.GetPieceList(PieceType.Queen, false).Count * 9;

        int materialAdvantage = whiteMaterial - blackMaterial;

        int materialWithoutPawns = (whiteMaterial + blackMaterial) - board.GetPieceList(PieceType.Pawn, true).Count
            - board.GetPieceList(PieceType.Pawn, false).Count;
        //float endGameWeight = (float)((Math.Clamp(1 - ((float)materialWithoutPawns) / 62, 0.25, 0.5) - 0.25) * 4);

       
        int bonusValues = 0;
        for (int i = 0; i < 64; i++)
        {
            Piece currentPiece = board.GetPiece(new Square(i));

            int sqaureIndex = currentPiece.IsWhite ? ((7 - (i / 8)) * 8) + i % 8 : i;
            int multiplier = currentPiece.IsWhite ? 1 : -1;
            
            bonusValues +=
                (int)(currentPiece.IsPawn ? extractBonusSqaure(0, sqaureIndex) :
                (currentPiece.IsKnight ? extractBonusSqaure(1, sqaureIndex) :
                (currentPiece.IsBishop ? extractBonusSqaure(2, sqaureIndex) :
                (currentPiece.IsRook ? extractBonusSqaure(3, sqaureIndex) :
                (currentPiece.IsQueen ? extractBonusSqaure(4, sqaureIndex) :
                (currentPiece.IsKing ? extractBonusSqaure(5, sqaureIndex) : 0)))))) * multiplier;
           
        }
        int evaluation = materialAdvantage * 100 + bonusValues;

        if (board.IsInCheckmate())
        {
            evaluation = board.IsWhiteToMove ? -2147483647 : 2147483647;
        }
        if (board.IsDraw())
        {
            evaluation = 0;
        }

        return evaluation;

    }

    //This code was from "Algorithms Explained – minimax and alpha-beta pruning" by Sebastian Lague
    public int MinMax(Board board, Timer timer, int depth, int plyFromRoot, int alpha, int beta, bool maximizingPlayer)
    {

        Move[] moves = board.GetLegalMoves();

        if (depth == 0 || board.IsInCheckmate() || board.IsDraw())
        {
            return Evaluate(board, timer) - (board.IsInCheckmate() ? ((maximizingPlayer ? -1 : 1) * plyFromRoot) : 0);
        }

        int bestEval = maximizingPlayer ? -2147483647 : 2147483647;
        foreach (Move currentMove in moves)
        {

            board.MakeMove(currentMove);
            
            int evaluation = MinMax(board, timer, depth - 1, plyFromRoot + 1, alpha, beta, !maximizingPlayer);
            board.UndoMove(currentMove);
            bestEval = maximizingPlayer ? Math.Max(bestEval, evaluation) : Math.Min(bestEval, evaluation);
            alpha = maximizingPlayer ? Math.Max(alpha, evaluation) : alpha;
            beta = maximizingPlayer ? beta : Math.Min(beta, evaluation);
            if (beta <= alpha)
            {
               break;
            }
        }
    
        return bestEval;
    }

            //Dictionary<ulong, int> transpositionTable = new Dictionary<ulong, int>();
    public Move Think(Board board, Timer timer)
    {
        Move[] moves = board.GetLegalMoves();

        int depth = 3;
        Move bestMove = moves[0];

        int bestEvaluation = board.IsWhiteToMove ? -2147483647 : 2147483647;
        bool maximizingPlayer = board.IsWhiteToMove;
        foreach (Move currentMove in moves)
        {
            
            board.MakeMove(currentMove);
            int currentEvaluation = MinMax(board, timer, depth - 1, 0, -2147483647, 2147483647, !maximizingPlayer);
            board.UndoMove(currentMove);
           
            if (maximizingPlayer)
            {
                if (currentEvaluation > bestEvaluation)
                {
                    bestMove = currentMove;
                }
                bestEvaluation = Math.Max(bestEvaluation, currentEvaluation);
                
            }
            else 
            {
                if (currentEvaluation < bestEvaluation)
                {
                    bestMove = currentMove;
                }
                bestEvaluation = Math.Min(bestEvaluation, currentEvaluation);
                
            }
            //Console.WriteLine(currentMove + board.GetFenString() + ": " + currentEvaluation);
        }
        return bestMove;
    }
}

but it's creating a lot of bad moves. I think it started when I added bonus values to the evaluation. It could be a very minor bug in my code but, I can't find it.

[jongdetim]

how did you pack the piece position tables into ulongs? i'm trying to do something similar, but it's a huge headache...

[jongdetim]

If, you don't mind, please. And how did you end up with 10x4 int64s? By naïve implementation, I'd pack 8x 8bit integers per 64-bit int with some bit shifting, ending up with 6 (pieces) x 8 x 64-bit ints.

[2tothe4th]

Each hex digit represents the bonus value for the square. Since the maximum hex digits you can have in a number is 16, I needed 4 subtables for all 64 squares. 4 subtables creates a piece square table.

using System;

namespace TablePacker // Note: actual namespace depends on the project name.
{
    internal class Program
    {
        static void Main(string[] args)
        {
            while (true)
            {
                string input = Console.ReadLine();


                input = input.Replace("-50", "E");
                input = input.Replace("-40", "D");
                input = input.Replace("-30", "C");
                input = input.Replace("-20", "B");
                input = input.Replace("-10", "A");
                input = input.Replace("-5", "9");

                input = input.Replace("50", "8");
                input = input.Replace("40", "7");
                input = input.Replace("30", "6");
                input = input.Replace("25", "5");
                input = input.Replace("20", "4");
                input = input.Replace("15", "3");
                input = input.Replace("10", "2");

                input = input.Replace("0", "0");
                input = input.Replace("5", "1");

                input = input.Replace(",", "");
                input = input.Replace(" ", "");
                input = input.Replace("\n", "");

                input = input.Insert(0, "0x");
                input = input.Insert(18, ", 0x");
                input = input.Insert(38, ", 0x");
                input = input.Insert(58, ", 0x");
                //input = input.Insert(70, ", ");


                Console.WriteLine(input);
                Console.ReadLine();
            }
        }
    }
}

[jongdetim]

I have to admit, i don't entirely follow, but it is almost 2 am here, so i will look at it again tomorrow. as i see it, you've used some clever encoding to map your square values to 15 possible values, which means you can map 16 scores in a single int, so indeed you would need 4 ints per piece to map all scores. I don't quite get why you end up with an array of 4x8 ints, and also why your 64-bit ints are not symmetrical.
Furthermore, i realized that if the scoring is indeed symmetrical, we'd only need half of that data to store our square bonus scores. I could be wrong, but i think it would be possible then to encode all the bonus square values into 6 (pieces) x 2 64-bit integers (64 / 2 = 32 squares, due to symmetry, times 4 bits per value, as per your encoding) for a total of only 12 integers.

[2tothe4th]

The kings values aren't symmetrical because of castling. Where the king ends up isn't symmetrical so I had to tweak the values.

[jongdetim]

There I disagree. Why would the king's values not be symmetrical? I don't see how castling is relevant. In the end I've decided to use half tables (as mine are symmetrical), and not use the packing method you used, but instead using 8 bits instead 4 per value, as it ends up being less tokens.