Пример #1
0
        public static MagicContainer[] GenerateRookAttacks(ulong[] keys = null)
        {
            var masks        = new ulong[64];
            var permutations = new ulong[64][];
            var attacks      = new ulong[64][];

            for (var fieldIndex = 0; fieldIndex < 64; fieldIndex++)
            {
                masks[fieldIndex] = (FilePatternGenerator.GetPatternForField(fieldIndex) & ~BoardConstants.TopBottomEdge) |
                                    (RankPatternGenerator.GetPatternForField(fieldIndex) & ~BoardConstants.RightLeftEdge);

                permutations[fieldIndex] = new ulong[1 << MagicShifts.RookShifts[fieldIndex]];
                attacks[fieldIndex]      = new ulong[1 << MagicShifts.RookShifts[fieldIndex]];

                for (var permutationIndex = 0; permutationIndex < permutations[fieldIndex].Length; permutationIndex++)
                {
                    permutations[fieldIndex][permutationIndex] = PermutationsGenerator.GetPermutation(masks[fieldIndex], permutationIndex);
                    attacks[fieldIndex][permutationIndex]      = AttacksGenerator.GetFileRankAttacks(permutations[fieldIndex][permutationIndex], fieldIndex);
                }
            }

            return(_rookMagicArray = GenerateAttacks(masks, permutations, attacks, MagicShifts.RookShifts, keys));
        }
Пример #2
0
        public static int Evaluate(BoardState board, int color, int openingPhase, int endingPhase)
        {
            var doubledRooks    = 0;
            var rooksOnOpenFile = 0;
            var enemyColor      = ColorOperations.Invert(color);

            var rooks = board.Pieces[color][Piece.Rook];

            while (rooks != 0)
            {
                var lsb   = BitOperations.GetLsb(rooks);
                var field = BitOperations.BitScan(lsb);
                rooks = BitOperations.PopLsb(rooks);

                var file                = FilePatternGenerator.GetPatternForField(field) | lsb;
                var rooksOnFile         = file & board.Pieces[color][Piece.Rook];
                var friendlyPawnsOnFile = file & board.Pieces[color][Piece.Pawn];
                var enemyPawnsOnFile    = file & board.Pieces[enemyColor][Piece.Pawn];

                if (BitOperations.Count(rooksOnFile) > 1)
                {
                    // We don't assume that there will be more than two rooks - even if, then this color is probably anyway winning
                    doubledRooks = 1;
                }

                if (friendlyPawnsOnFile == 0 && enemyPawnsOnFile == 0)
                {
                    rooksOnOpenFile++;
                }
            }

            var doubledRooksOpeningScore    = doubledRooks * EvaluationConstants.DoubledRooks;
            var rooksOnOpenFileOpeningScore = rooksOnOpenFile * EvaluationConstants.RookOnOpenFile;
            var openingScore = doubledRooksOpeningScore + rooksOnOpenFileOpeningScore;

            return(TaperedEvaluation.AdjustToPhase(openingScore, 0, openingPhase, endingPhase));
        }