Implement complex move types

ChessAI.sln

@@ -2,6 +2,10 @@
 Microsoft Visual Studio Solution File, Format Version 12.00
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ChessAI", "ChessAI\ChessAI.csproj", "{D75AC44F-AC92-418E-8B9B-6911AE1FE830}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "UnitTests", "UnitTests\UnitTests.csproj", "{0AB26848-CC9A-4CB1-AA2D-439A45A2DE66}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ChessBenchMarks", "ChessBenchMarks\ChessBenchMarks.csproj", "{3E43ADE7-9DE7-4D19-BA25-890FD9A41D0D}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -12,5 +16,13 @@ Global
 		{D75AC44F-AC92-418E-8B9B-6911AE1FE830}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{D75AC44F-AC92-418E-8B9B-6911AE1FE830}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{D75AC44F-AC92-418E-8B9B-6911AE1FE830}.Release|Any CPU.Build.0 = Release|Any CPU
+		{0AB26848-CC9A-4CB1-AA2D-439A45A2DE66}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{0AB26848-CC9A-4CB1-AA2D-439A45A2DE66}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{0AB26848-CC9A-4CB1-AA2D-439A45A2DE66}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{0AB26848-CC9A-4CB1-AA2D-439A45A2DE66}.Release|Any CPU.Build.0 = Release|Any CPU
+		{3E43ADE7-9DE7-4D19-BA25-890FD9A41D0D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{3E43ADE7-9DE7-4D19-BA25-890FD9A41D0D}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{3E43ADE7-9DE7-4D19-BA25-890FD9A41D0D}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{3E43ADE7-9DE7-4D19-BA25-890FD9A41D0D}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 EndGlobal

ChessAI/ChessAI.csproj

@@ -2,7 +2,8 @@
 
     <PropertyGroup>
         <OutputType>Exe</OutputType>
-        <TargetFramework>netcoreapp3.1</TargetFramework>
+        <TargetFramework>net5.0</TargetFramework>
+        <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     </PropertyGroup>
 
 </Project>

ChessAI/DataClasses/Board.cs

@@ -0,0 +1,124 @@
+using System;
+using System.Collections.Generic;
+
+namespace ChessAI.DataClasses
+{
+    public readonly struct Board
+    {
+        private const byte Width = 0x10;
+        private const byte Height = 0x8;
+        private static readonly sbyte[] Directions = {
+            +0x10, // 1 up
+            -0x10, // 1 down
+            +0x01, // 1 right
+            -0x01, // 1 left
+        };
+
+        public static sbyte WhiteDirection(Direction direction) => Directions[(byte)direction];
+        public static sbyte BlackDirection(Direction direction) => (sbyte) -(Directions[(byte)direction]);
+
+        private readonly Piece[] _fields; //TODO consider replacing this array with a stack allocated ReadOnlySpan<T>
+
+        /// <summary>
+        /// A constructor taking an array of pieces representing the board. Note that the array length must
+        /// be consistent with an 0x88 board.
+        /// </summary>
+        /// <param name="fields">an array representing the board</param>
+        /// <exception cref="ArgumentException">thrown if the given array is not of the right length</exception>
+        public Board(Piece[] fields)
+        {
+            var expectedSize = Width * Height;
+            if (fields.Length != expectedSize)
+            {
+                throw new ArgumentException(
+                    "fields must be an array of length 0x" + expectedSize.ToString("X") + " / 0d" + expectedSize + 
+                    " but the provided array had length 0x" + fields.Length.ToString("X") + " / 0d" + fields.Length
+                );
+            }
+
+            _fields = fields;
+        }
+
+        /// <summary>
+        /// A Constructor that takes a list of fields. It is assumed that all pieces have valid positions set.
+        /// If one or more pieces has an invalid position it can lead to unexpected behavior.
+        /// </summary>
+        /// <param name="pieceList">A list of pieces with valid positions</param>
+        public Board(List<Piece> pieceList)
+        {
+            var fields = new Piece[Width * Height];
+            foreach (var piece in pieceList)
+            {
+                fields[piece.Position] = piece;
+            }
+
+            _fields = fields;
+        }
+
+        public Piece this[int i] => Fields[i];
+
+        public ReadOnlySpan<Piece> Fields => _fields.AsSpan();
+
+        public bool IsFieldOccupied(byte position)
+        {
+            return Fields[position] == Piece.Empty;
+        }
+
+        public static bool IsIndexValid(byte index)
+        {
+            //Checks that only bits used for counting from 0-7 is used for each digit in the hex representation of the index
+            return (index & 0b1000_1000) == 0;
+        }
+
+        public static string IndexToString(byte index)
+        {
+            if (!IsIndexValid(index)) throw new ArgumentException("Argument must be a valid index");
+
+            return (index & 0xF0) switch
+            {
+                0x00 => "A" + (index & 0xF),
+                0x10 => "B" + (index & 0xF),
+                0x20 => "C" + (index & 0xF),
+                0x30 => "D" + (index & 0xF),
+                0x40 => "E" + (index & 0xF),
+                0x50 => "F" + (index & 0xF),
+                0x60 => "G" + (index & 0xF),
+                0x70 => "H" + (index & 0xF),
+                _ => throw new ArgumentException("Argument must be a valid index")
+            };
+        }
+
+        public static byte StringToIndex(string fieldName)
+        {
+            if (fieldName.Length != 2
+                || !"ABCDEFGHabcdefgh".Contains(fieldName[0])
+                || !"12345678".Contains(fieldName[1]))
+            {
+                throw new ArgumentException("Argument must be a valid field name");
+            }
+
+            var lastDigit = Byte.Parse(fieldName.Substring(1));
+            return (fieldName[0]) switch
+            {
+                'A' => (byte)(0x00 + lastDigit),
+                'B' => (byte)(0x10 + lastDigit),
+                'C' => (byte)(0x20 + lastDigit),
+                'D' => (byte)(0x30 + lastDigit),
+                'E' => (byte)(0x40 + lastDigit),
+                'F' => (byte)(0x50 + lastDigit),
+                'G' => (byte)(0x60 + lastDigit),
+                'H' => (byte)(0x70 + lastDigit),
+                _ => throw new ArgumentException("Argument must be a valid index")
+            };
+        }
+    }
+
+    public enum Direction : byte
+    {
+        Up = 0,
+        Down = 1,
+        Left = 2,
+        Right = 3,
+    };
+
+}

ChessAI/DataClasses/GameState.cs

@@ -0,0 +1,92 @@
+using System;
+using System.Collections.Generic;
+using static ChessAI.DataClasses.Piece;
+
+namespace ChessAI.DataClasses
+{
+    /**
+     * <summary>
+     * A struct that keeps track of all relevant information about a game
+     * </summary>
+     */
+    public readonly struct GameState
+    {
+        /// <summary>
+        /// An easy to use constructor taking only a board.
+        /// </summary>
+        /// <param name="board">The board that should be represented by this state</param>
+        /// <remarks>
+        /// This implementation is slow as it has to construct a PieceList itself.
+        /// Use other constructors in time critical sections of code.
+        /// </remarks>
+        public GameState(Board board)
+        {
+            State = board;
+
+            Span<Piece> tempBoardFields = stackalloc Piece[State.Fields.Length];
+            State.Fields.CopyTo(tempBoardFields);
+
+            List<Piece> tempWhitePieceList = new List<Piece>();
+            List<Piece> tempBlackPieceList = new List<Piece>();
+
+            // Fill PieceLists
+            for (byte index = 0; index < 0x88; index++)
+            {
+                // if the index is invalid we have exceeded the boundaries of the board.
+                // The body of the loop is skipped until the next valid index is encountered.
+                if (!Board.IsIndexValid(index)) continue; 
+
+                var currentPiece = board[index];
+                if (currentPiece.PieceType != Empty)
+                {
+
+                    // If the found piece doesn't have the right position then set it 
+                    if (currentPiece.Position != index)
+                    {
+                        currentPiece = new Piece(currentPiece.Content, index);
+                        tempBoardFields[index] = currentPiece;
+                    }
+
+                    if ((currentPiece.PieceFlags & White) == White)
+                    {
+                        tempWhitePieceList.Add(currentPiece);
+                    }
+                    else
+                    {
+                        tempBlackPieceList.Add(currentPiece);
+                    }
+                }
+            }
+
+            State = new Board(tempBoardFields.ToArray());
+            WhitePieces = tempWhitePieceList.ToArray();
+            BlackPieces = tempBlackPieceList.ToArray();
+        }
+
+        public readonly Board State;
+        public readonly Piece[] WhitePieces;
+        public readonly Piece[] BlackPieces;
+
+
+        /**
+         * <summary>A dummy method representing some logic to calculate the applying a move to the state</summary>
+         * <param name="move">The move that should be applied to a state</param>
+         * <returns>A new <see cref="GameState"/> with the move applied</returns>
+         */
+        public GameState ApplyMove(Move move)
+        {
+            Span<Piece> newFields = stackalloc Piece[State.Fields.Length];
+            State.Fields.CopyTo(newFields);
+
+            var movedPiece = newFields[move.StartPos];
+            newFields[move.StartPos] = new Piece(Empty);
+            var capturedPiece = newFields[move.EndPos];
+            newFields[move.EndPos] = movedPiece;
+
+            //TODO use another constructor to make this implementation faster (perhaps make one that takes a span)
+            var newBoard = new Board(newFields.ToArray());
+            var newState = new GameState(newBoard);
+            return newState;
+        }
+    }
+}

ChessAI/DataClasses/Move.cs

@@ -0,0 +1,141 @@
+using System;
+using static ChessAI.DataClasses.MoveType;
+using static ChessAI.DataClasses.Piece;
+
+namespace ChessAI.DataClasses
+{
+    public readonly struct Move
+    {
+        public readonly byte StartPos;
+        public readonly byte EndPos;
+        public readonly MoveType MoveType;
+        public readonly Piece MovePiece;
+        public readonly Piece TargetPiece;
+
+
+        /// <summary>
+        /// a simple constructor taking the start and end position.
+        /// </summary>
+        /// <param name="startPos">starting position</param>
+        /// <param name="endPos">destination</param>
+        /// <remarks>
+        /// This constructor has only been left here for compatibility concerns and should not be used.
+        /// When encountered it should be replaced by a factory method call.
+        /// The <see cref="CreateSimpleMove"/> Factory is the recommended alternative. It makes sure to set all the
+        /// required fields in the correct way only given start and end position and a state.
+        /// </remarks>
+        [ObsoleteAttribute("When encountered it should be replaced by a factory method call."
+                           + "The CreateSimpleMove Factory is the recommended alternative.", false)]
+        public Move(byte startPos, byte endPos)
+        {
+            StartPos = startPos;
+            EndPos = endPos;
+
+            MoveType = Ordinary;
+            MovePiece = new Piece(Empty);
+            TargetPiece = MovePiece;
+        }
+
+        /// <summary>
+        /// A constructor that takes all the required parameters to define a move
+        /// </summary>
+        /// <param name="startPos"></param>
+        /// <param name="endPos"></param>
+        /// <param name="isSpecialMove"></param>
+        /// <param name="movePiece"></param>
+        /// <param name="targetPiece"></param>
+        private Move(byte startPos, byte endPos, MoveType moveType, Piece movePiece, Piece targetPiece)
+        {
+            StartPos = startPos;
+            EndPos = endPos;
+            MoveType = moveType;
+            MovePiece = movePiece;
+            TargetPiece = targetPiece;
+        }
+
+        /// <summary>
+        /// A factory method that creates a simple move where no special rules are involved.
+        /// </summary>
+        /// <param name="startPos">The position from which the movePiece originates</param>
+        /// <param name="endPos">The destination of the movePiece</param>
+        /// <param name="state">The state of the game at the time of the move</param>
+        /// <returns>A new move from startPos to endPos</returns>
+        public static Move CreateSimpleMove(byte startPos, byte endPos, GameState state)
+        {
+            var movePiece = state.State[startPos];
+            var targetPiece = state.State[endPos];
+            var move = new Move(startPos, endPos, Ordinary, movePiece, targetPiece);
+            return move;
+        }
+
+        /// <summary>
+        /// A factory method that creates a castling move.
+        /// This method performs no checks on the legality of the move, not even if the pieces required are
+        /// actually there. This method should therefore only be called after the legality has been determined.
+        /// </summary>
+        /// <param name="castlePosition">The position of the rook that is involved in the castling</param>
+        /// <param name="state">The state of the game at the time of the move</param>
+        /// <returns>
+        /// A new castling move that represents the king taking the castlePosition and the
+        /// occupying rook being moved in the appropriate direction
+        /// </returns>
+        public static Move CreateCastleMove(byte castlePosition, GameState state)
+        {
+            var targetPiece = state.State[castlePosition];
+
+            // Dependant on the board. Should this be a static member of board?
+            byte whiteKingIndex = 0x04;
+            byte blackKingIndex = 0x73;
+
+            var kingIndex = (targetPiece.PieceFlags & White) == White ? whiteKingIndex : blackKingIndex;
+            var movePiece = state.State[kingIndex];
+
+            var move = new Move(kingIndex, castlePosition, Castling, movePiece, targetPiece);
+            return move;
+        }
+
+        /// <summary>
+        /// A factory method that creates a pwn promotion move.
+        /// This method performs no checks on the legality of the move, not even if the pieces required are
+        /// actually there. This method should therefore only be called after the legality has been determined. 
+        /// </summary>
+        /// <param name="startPosition">The starting position of the pawn</param>
+        /// <param name="endPos">
+        /// The destination of the pawn. note that this may also occur through an attack
+        /// which opens the possibility of three different end positions
+        /// </param>
+        /// <param name="promotionPiece">The piece the pawn should be promoted to</param>
+        /// <param name="state">The state of the game at the time of the move</param>
+        /// <returns>
+        /// A new pawn promotion move that represents a pawn moving to the 8th rank, being promote to the promotionPiece
+        /// </returns>
+        public static Move CreatePawnPromotionMove(byte startPosition, byte endPos, Piece promotionPiece,
+            GameState state)
+        {
+            var movePiece = state.State[startPosition];
+            var promotionType = promotionPiece.PieceType switch
+            {
+                Queen => PromotionQueen,
+                Knight => PromotionKnight,
+                Bishop => PromotionBishop,
+                Rook => PromotionRook,
+                _ => throw new ArgumentOutOfRangeException(
+                    $"The piece type {promotionPiece.PieceType} is not an option for promotion"
+                )
+            };
+
+            var move = new Move(startPosition, endPos, promotionType, movePiece, promotionPiece);
+            return move;
+        }
+    }
+
+    public enum MoveType : byte
+    {
+        Ordinary,
+        Castling,
+        PromotionQueen,
+        PromotionRook,
+        PromotionBishop,
+        PromotionKnight
+    }
+}