CRapShort.cs

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Threading;

namespace RapShortCs
{
    struct CUndo
    {
        public int captured;
        public int passing;
        public int castle;
        public int move50;
        public int lastCastle;
        public ulong hash;
    }

    class CUci
    {
        public string command;
        public string[] tokens;

        public int GetIndex(string key, int def)
        {
            for (int n = 0; n < tokens.Length; n++)
                if (tokens[n] == key)
                    return n;
            return def;
        }

        public int GetInt(string key, int def)
        {
            for (int n = 0; n < tokens.Length - 1; n++)
                if (tokens[n] == key)
                    return Int32.Parse(tokens[n + 1]);
            return def;
        }

        public string GetValue(string start)
        {
            int istart = GetIndex(start, tokens.Length);
            return GetValue(istart + 1);
        }

        public string GetValue(string start, string end)
        {
            int istart = GetIndex(start, tokens.Length);
            int iend = GetIndex(end, tokens.Length);
            return GetValue(istart + 1, iend - 1);
        }

        public string GetValue(int start, int end = 0)
        {
            string result = string.Empty;
            if (start < 0)
                start = 0;
            if ((end < start) || (end >= tokens.Length))
                end = tokens.Length - 1;
            for (int n = start; n <= end; n++)
                result += $" {tokens[n]}";
            return result.Trim();
        }

        public void SetMsg(string msg)
        {
            if (String.IsNullOrEmpty(msg))
            {
                tokens = new string[0];
                command = string.Empty;
            }
            else
            {
                tokens = msg.Trim().Split(' ');
                command = tokens[0];
            }
        }
    }

    struct D2
    {
        public int x;
        public int y;

        public D2(int sx, int sy)
        {
            x = sx;
            y = sy;
        }
    }

    class CChess
    {
        const int piecePawn = 0x01;
        const int pieceKnight = 0x02;
        const int pieceBishop = 0x03;
        const int pieceRook = 0x04;
        const int pieceQueen = 0x05;
        const int pieceKing = 0x06;
        const int colorBlack = 0x08;
        const int colorWhite = 0x10;
        const int colorEmpty = 0x20;
        const int moveflagPassing = 0x02 << 16;
        public const int moveflagCastleKing = 0x04 << 16;
        public const int moveflagCastleQueen = 0x08 << 16;
        const int moveflagPromoteQueen = pieceQueen << 20;
        const int moveflagPromoteRook = pieceRook << 20;
        const int moveflagPromoteBishop = pieceBishop << 20;
        const int moveflagPromoteKnight = pieceKnight << 20;
        const int maskCastle = moveflagCastleKing | moveflagCastleQueen;
        const int maskColor = colorBlack | colorWhite;
        const int maskPromotion = moveflagPromoteQueen | moveflagPromoteRook | moveflagPromoteBishop | moveflagPromoteKnight;
        const int maskPassPromotion = maskPromotion | moveflagPassing;
        const int maskRank = 7;
        int usColor = 0;
        int enColor = 0;
        int inTime = 0;
        int inDepth = 0;
        int inNodes = 0;
        int castleRights = 0xf;
        ulong hash = 0;
        int passing = 0;
        public int move50 = 0;
        int halfMove = 0;
        int totalNodes = 0;
        bool inCheck = false;
        int g_timeout = 0;
        int g_depthout = 0;
        int g_nodeout = 0;
        int mainDepth = 1;
        bool g_stop = false;
        int lastCastle = 0;
        public int undoIndex = 0;
        readonly int[] board = new int[64];
        readonly ulong[,] hashBoard = new ulong[64, 16];
        readonly int[] boardCheck = new int[64];
        readonly int[] boardCastle = new int[64];
        public bool whiteTurn = true;
        string bsFm = String.Empty;
        string bsPv = String.Empty;
        readonly int[] bonMaterial = new int[7] { 0, 100, 340, 350, 525, 800, 0xffff };
        readonly D2[] arrDirKinght = { new D2(-2, -1), new D2(-2, 1), new D2(2, -1), new D2(2, 1), new D2(-1, -2), new D2(-1, 2), new D2(1, -2), new D2(1, 2) };
        readonly D2[] arrDirBishop = { new D2(-1, -1), new D2(-1, 1), new D2(1, -1), new D2(1, 1) };
        readonly D2[] arrDirRook = { new D2(-1, 0), new D2(1, 0), new D2(0, -1), new D2(0, 1) };
        readonly D2[] arrDirQueen = { new D2(-1, -1), new D2(-1, 1), new D2(1, -1), new D2(1, 1), new D2(-1, 0), new D2(1, 0), new D2(0, -1), new D2(0, 1) };
        public static Random random = new Random();
        readonly CUndo[] undoStack = new CUndo[0xfff];
        Thread startThread;
        public Stopwatch stopwatch = Stopwatch.StartNew();
        public CSynStop synStop = new CSynStop();

        public CChess()
        {
            hash = RAND_32();
            for (int n = 0; n < 64; n++)
            {
                boardCastle[n] = 15;
                boardCheck[n] = 0;
                board[n] = 0;
                for (int p = 0; p < 16; p++)
                    hashBoard[n, p] = RAND_32();
            }
            boardCastle[0] = 7;
            boardCastle[4] = 3;
            boardCastle[7] = 11;
            boardCastle[56] = 13;
            boardCastle[60] = 12;
            boardCastle[63] = 14;
            boardCheck[3] = colorBlack | moveflagCastleQueen;
            boardCheck[4] = colorBlack | maskCastle;
            boardCheck[5] = colorBlack | moveflagCastleKing;
            boardCheck[59] = colorWhite | moveflagCastleQueen;
            boardCheck[60] = colorWhite | maskCastle;
            boardCheck[61] = colorWhite | moveflagCastleKing;
            SetFen();
        }

        ulong RAND_32()
        {
            return ((ulong)random.Next() << 32) | ((ulong)random.Next() << 0);
        }

        bool GetBoard(int x, int y, out int v)
        {
            v = 0;
            if ((x < 0) || (y < 0) || (x > 7) || (y > 7))
                return false;
            v = board[y * 8 + x];
            return true;
        }

        string EmoToUmo(int move)
        {
            string result = SquToStr(move & 0xFF) + SquToStr((move >> 8) & 0xFF);
            int promotion = move & maskPromotion;
            if (promotion > 0)
            {
                if (promotion == moveflagPromoteQueen) result += 'q';
                else if (promotion == moveflagPromoteRook) result += 'r';
                else if (promotion == moveflagPromoteBishop) result += 'b';
                else result += 'n';
            }
            return result;
        }

        public int UmoToEmo(string umo)
        {
            List<int> moves = GenerateAllMoves(whiteTurn, out _, out _);
            foreach (int m in moves)
                if (EmoToUmo(m) == umo)
                    return m;
            return 0;
        }

        string SquToStr(int square)
        {
            int x = (square & 7);
            int y = (square >> 3);
            string xs = "abcdefgh";
            string ys = "87654321";
            return $"{xs[x]}{ys[y]}";
        }

        int StrToSqu(string s)
        {
            string xs = "abcdefgh";
            string ys = "87654321";
            int x = xs.IndexOf(s[0]);
            int y = ys.IndexOf(s[1]);
            return (y << 3) | x;
        }

        bool IsRepetition()
        {
            for (int n = undoIndex - 2; n >= undoIndex - move50; n -= 2)
                if (undoStack[n].hash == hash)
                    return true;
            return false;
        }

        public void MakeMoves(string moves)
        {
            string[] am = moves.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
            foreach (string m in am)
            {
                int emo = UmoToEmo(m);
                if (emo > 0)
                    MakeMove(emo);
            }
        }

        void GeneratePawnAttack(List<int> moves, int fr, int to)
        {
            if (to == passing)
                GenerateMove(moves, fr, to, moveflagPassing, true);
            else if ((board[to] & colorEmpty) > 0)
                GenerateMove(moves, fr, to, 0, false);
            else if ((board[to] & enColor) > 0)
                GeneratePawnMoves(moves, fr, to, 0, true);
        }

        void GeneratePawnMoves(List<int> moves, int fr, int to, int flag, bool add)
        {
            int y = to >> 3;
            if ((y == 0) || (y == 7))
            {
                GenerateMove(moves, fr, to, moveflagPromoteQueen, true);
                GenerateMove(moves, fr, to, moveflagPromoteRook, true);
                GenerateMove(moves, fr, to, moveflagPromoteBishop, true);
                GenerateMove(moves, fr, to, moveflagPromoteKnight, true);
            }
            else
                GenerateMove(moves, fr, to, flag, add);
        }

        void GenerateUniMoves(List<int> moves, int fx, int fy, D2[] dir, int count, ref int score)
        {
            for (int n = 0; n < dir.Length; n++)
            {
                int fr = fy * 8 + fx;
                int dx = fx;
                int dy = fy;
                int c = count;
                while (c-- > 0)
                {
                    D2 d = dir[n];
                    dx += d.x;
                    dy += d.y;
                    if (!GetBoard(dx, dy, out int sq))
                        break;
                    int to = dy * 8 + dx;
                    if ((sq & colorEmpty) > 0)
                    {
                        score++;
                        GenerateMove(moves, fr, to, 0, true);
                    }
                    else if ((sq & enColor) > 0)
                    {
                        score += 2;
                        GenerateMove(moves, fr, to, 0, true);
                        break;
                    }
                    else
                        break;
                }
            }
        }

        public void SetFen(string fen = "")
        {
            lastCastle = 0;
            synStop.SetStop(false);
            if (fen == "") fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
            string[] chunks = fen.Split();
            for (int n = 0; n < 64; n++)
                board[n] = colorEmpty;
            int row = 0;
            int col = 0;
            string pieces = chunks[0];
            for (int i = 0; i < pieces.Length; i++)
            {
                char c = pieces[i];
                if (c == '/')
                {
                    row++;
                    col = 0;
                }
                else if (c >= '0' && c <= '9')
                {
                    for (int j = 0; j < Int32.Parse(c.ToString()); j++)
                        col++;
                }
                else
                {
                    int piece = Char.IsUpper(c) ? colorWhite : colorBlack;
                    int index = (row << 3) | col;
                    switch (Char.ToLower(c))
                    {
                        case 'p':
                            piece |= piecePawn;
                            break;
                        case 'b':
                            piece |= pieceBishop;
                            break;
                        case 'n':
                            piece |= pieceKnight;
                            break;
                        case 'r':
                            piece |= pieceRook;
                            break;
                        case 'q':
                            piece |= pieceQueen;
                            break;
                        case 'k':
                            piece |= pieceKing;
                            break;
                    }
                    board[index] = piece;
                    col++;
                }
            }
            whiteTurn = chunks[1] == "w";
            castleRights = 0;
            if (chunks[2].IndexOf('K') != -1)
                castleRights |= 1;
            if (chunks[2].IndexOf('Q') != -1)
                castleRights |= 2;
            if (chunks[2].IndexOf('k') != -1)
                castleRights |= 4;
            if (chunks[2].IndexOf('q') != -1)
                castleRights |= 8;
            passing = 0;
            if (chunks[3].IndexOf('-') == -1)
                passing = StrToSqu(chunks[3]);
            move50 = 0;
            halfMove = Int32.Parse(chunks[5]);
            if (halfMove > 0) halfMove--;
            halfMove *= 2;
            if (!whiteTurn) halfMove++;
            undoIndex = move50;
        }

        public void MakeMove(int move)
        {
            ref CUndo undo = ref undoStack[undoIndex++];
            undo.hash = hash;
            undo.passing = passing;
            undo.castle = castleRights;
            undo.move50 = move50;
            undo.lastCastle = lastCastle;
            int fr = move & 0xff;
            int to = (move >> 8) & 0xff;
            int piecefr = board[fr];
            int piece = piecefr & 0xf;
            int captured = board[to];
            lastCastle = (move & maskCastle) | (piecefr & maskColor);
            if ((move & moveflagCastleKing) > 0)
            {
                board[to - 1] = board[to + 1];
                board[to + 1] = colorEmpty;
            }
            else if ((move & moveflagCastleQueen) > 0)
            {
                board[to + 1] = board[to - 2];
                board[to - 2] = colorEmpty;
            }
            else if ((move & moveflagPassing) > 0)
            {
                int capi = whiteTurn ? to + 8 : to - 8;
                captured = board[capi];
                board[capi] = colorEmpty;
            }
            undo.captured = captured;
            hash ^= hashBoard[fr, piece];
            passing = -1;
            if ((captured & 0xf) > 0)
                move50 = 0;
            else if ((piece & 7) == piecePawn)
            {
                if (to == (fr + 16))
                    passing = fr + 8;
                if (to == (fr - 16))
                    passing = fr - 8;
                move50 = 0;
            }
            else
                move50++;
            int newPiece = ((move & maskPromotion) > 0) ? (piecefr & maskColor) | ((move >> 20) & maskRank) : piecefr;
            board[fr] = colorEmpty;
            board[to] = newPiece;
            hash ^= hashBoard[to, newPiece & 0xf];
            castleRights &= boardCastle[fr] & boardCastle[to];
            halfMove++;
            whiteTurn ^= true;
        }

        public void UnmakeMove(int move)
        {
            int fr = move & 0xFF;
            int to = (move >> 8) & 0xFF;
            int capi = to;
            CUndo undo = undoStack[--undoIndex];
            passing = undo.passing;
            castleRights = undo.castle;
            move50 = undo.move50;
            lastCastle = undo.lastCastle;
            hash = undo.hash;
            int captured = undo.captured;
            if ((move & moveflagCastleKing) > 0)
            {
                board[to + 1] = board[to - 1];
                board[to - 1] = colorEmpty;
            }
            else if ((move & moveflagCastleQueen) > 0)
            {
                board[to - 2] = board[to + 1];
                board[to + 1] = colorEmpty;
            }
            if ((move & maskPromotion) > 0)
            {
                int piece = (board[to] & (~0x7)) | piecePawn;
                board[fr] = piece;
            }
            else board[fr] = board[to];
            if ((move & moveflagPassing) > 0)
            {
                capi = whiteTurn ? to - 8 : to + 8;
                board[to] = colorEmpty;
            }
            board[capi] = captured;
            halfMove--;
            whiteTurn ^= true;
        }

        bool GetStop()
        {
            return ((g_timeout > 0) && (stopwatch.Elapsed.TotalMilliseconds > g_timeout)) || ((g_depthout > 0) && (mainDepth > g_depthout)) || ((g_nodeout > 0) && (totalNodes > g_nodeout));
        }

        List<int> GenerateAllMoves(bool wt, out int score, out bool insufficient)
        {
            score = 0;
            inCheck = false;
            usColor = wt ? colorWhite : colorBlack;
            enColor = wt ? colorBlack : colorWhite;
            int pieceP = 0;
            int pieceN = 0;
            int pieceB = 0;
            int pieceM = 0;
            int kpx = 0;
            int kpy = 0;
            List<int> moves = new List<int>(64);
            for (int x = 0; x < 8; x++)
            {
                for (int y = 0; y < 8; y++)
                {
                    int fr = (y << 3) | x;
                    int f = board[fr];
                    if ((f & usColor) > 0) f &= 7;
                    else continue;
                    score += bonMaterial[f];
                    switch (f)
                    {
                        case 1:
                            pieceP++;
                            int del = wt ? -1 : 1;
                            int to = fr + del * 8;
                            score += wt ? 1 << (7 - y) : 1 << y;
                            if (((board[to] & colorEmpty) > 0))
                            {
                                GeneratePawnMoves(moves, fr, to, 0, true);
                                int d = wt ? 6 : 1;
                                if ((y == d) && (board[fr + del * 16] & colorEmpty) > 0)
                                    GeneratePawnMoves(moves, fr, fr + del * 16, 0, true);
                            }
                            if (GetBoard(x - 1, y + del, out _))
                                GeneratePawnAttack(moves, fr, to - 1);
                            if (GetBoard(x + 1, y + del, out _))
                                GeneratePawnAttack(moves, fr, to + 1);
                            break;
                        case 2:
                            pieceN++;
                            GenerateUniMoves(moves, x, y, arrDirKinght, 1, ref score);
                            break;
                        case 3:
                            pieceB++;
                            GenerateUniMoves(moves, x, y, arrDirBishop, 7, ref score);
                            break;
                        case 4:
                            pieceM++;
                            GenerateUniMoves(moves, x, y, arrDirRook, 7, ref score);
                            break;
                        case 5:
                            pieceM++;
                            GenerateUniMoves(moves, x, y, arrDirQueen, 7, ref score);
                            break;
                        case 6:
                            kpx = x;
                            kpy = y;
                            GenerateUniMoves(moves, x, y, arrDirQueen, 1, ref score);
                            int cr = wt ? castleRights : castleRights >> 2;
                            if ((cr & 1) > 0)
                                if (((board[fr + 1] & colorEmpty) > 0) && ((board[fr + 2] & colorEmpty) > 0))
                                    GenerateMove(moves, fr, fr + 2, moveflagCastleKing, true);
                            if ((cr & 2) > 0)
                                if (((board[fr - 1] & colorEmpty) > 0) && ((board[fr - 2] & colorEmpty) > 0) && ((board[fr - 3] & colorEmpty) > 0))
                                    GenerateMove(moves, fr, fr - 2, moveflagCastleQueen, true);
                            break;
                    }
                }
            }
            if (pieceB > 1)
                score += 0x40;
            int dx = Math.Abs((kpx << 1) - 7) >> 1;
            int dy = Math.Abs((kpy << 1) - 7) >> 1;
            int phase = pieceP + pieceN + pieceB + pieceM;
            score += (phase - 8) * (dx + dy);
            insufficient = (pieceP + pieceM == 0) && (pieceN + (pieceB << 1) < 3);
            return moves;
        }

        void GenerateMove(List<int> moves, int fr, int to, int flag, bool add)
        {
            int rank = board[to] & 7;
            if (((board[to] & 7) == pieceKing) || (((boardCheck[to] & lastCastle) == lastCastle) && ((lastCastle & maskCastle) > 0)))
                inCheck = true;
            else if (add)
                if ((rank > 0) || ((flag & maskPassPromotion) > 0))
                    moves.Insert(0, fr | (to << 8) | flag);
                else
                    moves.Add(fr | (to << 8) | flag);

        }

        int Search(List<int> mu, int ply, int depth, int alpha, int beta, int usScore, bool usInsufficient, ref int alDe, ref string alPv, out int myMoves)
        {
            int neDe = 0;
            string nePv = String.Empty;
            myMoves = 0;
            if (g_stop)
                return alpha;
            for (int n = 0; n < mu.Count; n++)
            {
                int cm = mu[n];
                alDe = 0;
                alPv = string.Empty;
                if ((++totalNodes & 0x1fff) == 0)
                    if (GetStop() || synStop.GetStop())
                        g_stop = mainDepth > 0;
                MakeMove(cm);
                List<int> me = GenerateAllMoves(whiteTurn, out int enScore, out bool enInsufficient);
                int score = usScore - enScore;
                if (usInsufficient != enInsufficient)
                    score += usInsufficient ? -400 : 400;
                if (inCheck)
                    score = -0xffff;
                else
                {
                    myMoves++;
                    if ((move50 > 99) || IsRepetition() || (usInsufficient && enInsufficient))
                        score = 0;
                    else if (depth > 1)
                        score = -Search(me, ply + 1, depth - 1, -beta, -alpha, enScore, enInsufficient, ref alDe, ref alPv, out _);
                }
                UnmakeMove(cm);
                if (score >= beta)
                    return beta;
                if (score > alpha)
                {
                    string alphaFm = EmoToUmo(cm);
                    nePv = $"{alphaFm} {alPv}";
                    neDe = alDe + 1;
                    alpha = score;
                    if (ply == 1)
                    {
                        string scFm = score > 0xf000 ? $"mate {(0xffff - score) >> 1}" : ((score < -0xf000) ? $"mate {(-0xfffe - score) >> 1}" : $"cp {score}");
                        bsFm = alphaFm;
                        bsPv = nePv;
                        if (n > 0)
                        {
                            mu.RemoveAt(n);
                            mu.Insert(0, cm);
                        }
                        double t = stopwatch.Elapsed.TotalMilliseconds;
                        double nps = t > 0 ? (totalNodes / t) * 1000 : 0;
                        Console.WriteLine($"info currmove {bsFm} currmovenumber {n+1} nodes {totalNodes} time {Convert.ToInt64(t)} nps {Convert.ToInt64(nps)} depth {mainDepth} seldepth {neDe} score {scFm} pv {nePv}");
                    }
                }
            }
            alDe = neDe;
            alPv = nePv;
            if (myMoves == 0)
            {
                GenerateAllMoves(!whiteTurn, out _, out _);
                return inCheck ? -0xffff + ply : 0;
            }
            return alpha;
        }

        public void Start(int depth, int time, int nodes)
        {
            List<int> mu = GenerateAllMoves(whiteTurn, out int usScore, out bool usInsufficient);
            int myMoves;
            g_stop = false;
            totalNodes = 0;
            g_timeout = time;
            g_depthout = depth;
            g_nodeout = nodes;
            mainDepth = 1;
            do
            {
                int alDe = 0;
                string alPv = string.Empty;
                int score = Search(mu, 1, mainDepth, -0xffff, 0xffff, usScore, usInsufficient, ref alDe, ref alPv, out myMoves);
                double t = stopwatch.Elapsed.TotalMilliseconds;
                double nps = t > 0 ? (totalNodes / t) * 1000 : 0;
                Console.WriteLine($"info depth {mainDepth} nodes {totalNodes} time {Convert.ToInt64(t)} nps {Convert.ToInt64(nps)}");
                mainDepth++;
                if (mainDepth > 100)
                    break;
                if ((score < -0xf000) || (score > 0xf000))
                    break;
            } while (!GetStop() && !synStop.GetStop() && (myMoves > 1));
            string[] ponder = bsPv.Trim().Split();
            string pm = ponder.Length > 1 ? $" ponder {ponder[1]}" : string.Empty;
            Console.WriteLine("bestmove " + bsFm + pm);
        }

        public void Thread()
        {
            Start(inDepth, inTime, inNodes);
        }

        public void StartThread(int depth, int time, int nodes)
        {
            inDepth = depth;
            inTime = time;
            inNodes = nodes;
            startThread = new Thread(Thread);
            startThread.Start();
        }

    }

    class CSynStop
    {
        private bool value = true;
        private readonly object locker = new object();

        public bool GetStop()
        {
            lock (locker)
            {
                return value;
            }
        }

        public void SetStop(bool v)
        {
            lock (locker)
            {
                value = v;
            }
        }

    }

    class CRapShort
    {
        static void Main()
        {
            string version = "2023-02-21";
            CChess chess = new CChess();
            CUci uci = new CUci();

            while (true)
            {
                string msg = Console.ReadLine();
                uci.SetMsg(msg);
                switch (uci.command)
                {
                    case "uci":
                        Console.WriteLine($"id name RapShortCs {version}");
                        Console.WriteLine("id author Thibor Raven");
                        Console.WriteLine("id link https://github.com/Thibor/RapShortCs");
                        Console.WriteLine("uciok");
                        break;
                    case "isready":
                        Console.WriteLine("readyok");
                        break;
                    case "position":
                        chess.SetFen(uci.GetValue("fen", "moves"));
                        chess.MakeMoves(uci.GetValue("moves"));
                        break;
                    case "go":
                        chess.stopwatch.Restart();
                        int time = uci.GetInt("movetime", 0);
                        int depth = uci.GetInt("depth", 0);
                        int node = uci.GetInt("nodes", 0);
                        int infinite = uci.GetIndex("infinite", 0);
                        if ((time == 0) && (depth == 0) && (node == 0) && (infinite == 0))
                        {
                            double ct = chess.whiteTurn ? uci.GetInt("wtime", 0) : uci.GetInt("btime", 0);
                            double inc = chess.whiteTurn ? uci.GetInt("winc", 0) : uci.GetInt("binc", 0);
                            double mg = uci.GetInt("movestogo", 32);
                            time = Convert.ToInt32((ct - 1000 + inc * mg) / mg);
                            if (time < 1)
                                time = 1;
                        }
                        chess.StartThread(depth, time, node);
                        break;
                    case "stop":
                        chess.synStop.SetStop(true);
                        break;
                    case "quit":
                        chess.synStop.SetStop(true);
                        return;
                }

            }
        }
    }
}