Original article was published by Ansh Gaikwad on Artificial Intelligence on Medium

**Board Evaluation**

For evaluating the board initially, we must think about how a Grandmaster would think in his respective match.

*Some of the**points**which should come in our mind are:*

- Avoid exchanging one minor piece for three pawns.
- Always have the bishop in pairs.
- Avoid exchanging two minor pieces for a rook and a pawn.

*So, the**equations**from the above insights will be:*

- Bishop > 3 Pawns & Knight > 3 Pawns
- Bishop > Knight
- Bishop + Knight > Rook + Pawn

By simplifying the above equations, we get Bishop > Knight > 3 Pawns. Also, we must convert the third equation as Bishop + Knight = Rook + 1.5 Pawn as two minor pieces are worth a rook and two pawns.

We will use **piece square tables** to evaluate our board pieces and the values will be set in an 8×8 matrix such as in chess such that it must have a **higher** value at favorable positions and a** lower** value at a non-favorable place.

For example, the probability of the white’s king crossing the centerline will be less than 20% and therefore we will place negative values in that matrix.

Let’s take another example, suppose the Queen, she would like her to be placed at the center position as she can dominate more number of positions from the center and therefore we will set higher values at the center and the same for the other pieces as chess is all about defending the king and dominating the center.

*Enough of the theory lets initialize the piece square tables:*

pawntable = [

0, 0, 0, 0, 0, 0, 0, 0,

5, 10, 10, -20, -20, 10, 10, 5,

5, -5, -10, 0, 0, -10, -5, 5,

0, 0, 0, 20, 20, 0, 0, 0,

5, 5, 10, 25, 25, 10, 5, 5,

10, 10, 20, 30, 30, 20, 10, 10,

50, 50, 50, 50, 50, 50, 50, 50,

0, 0, 0, 0, 0, 0, 0, 0]

knightstable = [

-50, -40, -30, -30, -30, -30, -40, -50,

-40, -20, 0, 5, 5, 0, -20, -40,

-30, 5, 10, 15, 15, 10, 5, -30,

-30, 0, 15, 20, 20, 15, 0, -30,

-30, 5, 15, 20, 20, 15, 5, -30,

-30, 0, 10, 15, 15, 10, 0, -30,

-40, -20, 0, 0, 0, 0, -20, -40,

-50, -40, -30, -30, -30, -30, -40, -50]bishopstable = [

-20, -10, -10, -10, -10, -10, -10, -20,

-10, 5, 0, 0, 0, 0, 5, -10,

-10, 10, 10, 10, 10, 10, 10, -10,

-10, 0, 10, 10, 10, 10, 0, -10,

-10, 5, 5, 10, 10, 5, 5, -10,

-10, 0, 5, 10, 10, 5, 0, -10,

-10, 0, 0, 0, 0, 0, 0, -10,

-20, -10, -10, -10, -10, -10, -10, -20]rookstable = [

0, 0, 0, 5, 5, 0, 0, 0,

-5, 0, 0, 0, 0, 0, 0, -5,

-5, 0, 0, 0, 0, 0, 0, -5,

-5, 0, 0, 0, 0, 0, 0, -5,

-5, 0, 0, 0, 0, 0, 0, -5,

-5, 0, 0, 0, 0, 0, 0, -5,

5, 10, 10, 10, 10, 10, 10, 5,

0, 0, 0, 0, 0, 0, 0, 0]queenstable = [

-20, -10, -10, -5, -5, -10, -10, -20,

-10, 0, 0, 0, 0, 0, 0, -10,

-10, 5, 5, 5, 5, 5, 0, -10,

0, 0, 5, 5, 5, 5, 0, -5,

-5, 0, 5, 5, 5, 5, 0, -5,

-10, 0, 5, 5, 5, 5, 0, -10,

-10, 0, 0, 0, 0, 0, 0, -10,

-20, -10, -10, -5, -5, -10, -10, -20]kingstable = [

20, 30, 10, 0, 0, 10, 30, 20,

20, 20, 0, 0, 0, 0, 20, 20,

-10, -20, -20, -20, -20, -20, -20, -10,

-20, -30, -30, -40, -40, -30, -30, -20,

-30, -40, -40, -50, -50, -40, -40, -30,

-30, -40, -40, -50, -50, -40, -40, -30,

-30, -40, -40, -50, -50, -40, -40, -30,

-30, -40, -40, -50, -50, -40, -40, -30]

*Now let’s get our evaluation function by following these four methods:*

**Firstly**, let’s check if the game is still going on.

Now the logic behind coding this stage is that If it returns true at checkmate then it will check whose turn to make a move, if the current turn is of WHITE it must return -9999 i.e previous turn must be of BLACK, and BLACK wins or else it must return +9999 and then White wins. For stalemate or any insufficient material, let’s return 0 as its draw.

So, let’s code:

`if board.is_checkmate():`

if board.turn:

return -9999

else:

return 9999

if board.is_stalemate():

return 0

if board.is_insufficient_material():

return 0

**Secondly**, we must calculate the total number of pieces so that we can pass it into our material function.

`wp = len(board.pieces(chess.PAWN, chess.WHITE))`

bp = len(board.pieces(chess.PAWN, chess.BLACK))

wn = len(board.pieces(chess.KNIGHT, chess.WHITE))

bn = len(board.pieces(chess.KNIGHT, chess.BLACK))

wb = len(board.pieces(chess.BISHOP, chess.WHITE))

bb = len(board.pieces(chess.BISHOP, chess.BLACK))

wr = len(board.pieces(chess.ROOK, chess.WHITE))

br = len(board.pieces(chess.ROOK, chess.BLACK))

wq = len(board.pieces(chess.QUEEN, chess.WHITE))

bq = len(board.pieces(chess.QUEEN, chess.BLACK))

**Third**, let’s calculate the scores.

The **material score** is calculated by the summation of all respective piece’s weights multiplied by the difference between the number of that respective piece between white and black.

The **individual pieces score** is the sum of piece-square values of positions where the respective piece is present at that instance of the game.

material = 100 * (wp - bp) + 320 * (wn - bn) + 330 * (wb - bb) + 500 * (wr - br) + 900 * (wq - bq)pawnsq = sum([pawntable[i] for i in board.pieces(chess.PAWN, chess.WHITE)])

pawnsq = pawnsq + sum([-pawntable[chess.square_mirror(i)]

for i in board.pieces(chess.PAWN, chess.BLACK)])knightsq = sum([knightstable[i] for i in board.pieces(chess.KNIGHT, chess.WHITE)])

knightsq = knightsq + sum([-knightstable[chess.square_mirror(i)]

for i in board.pieces(chess.KNIGHT, chess.BLACK)])bishopsq = sum([bishopstable[i] for i in board.pieces(chess.BISHOP, chess.WHITE)])

bishopsq = bishopsq + sum([-bishopstable[chess.square_mirror(i)]

for i in board.pieces(chess.BISHOP, chess.BLACK)])rooksq = sum([rookstable[i] for i in board.pieces(chess.ROOK, chess.WHITE)])

rooksq = rooksq + sum([-rookstable[chess.square_mirror(i)]

for i in board.pieces(chess.ROOK, chess.BLACK)])queensq = sum([queenstable[i] for i in board.pieces(chess.QUEEN, chess.WHITE)])

queensq = queensq + sum([-queenstable[chess.square_mirror(i)]

for i in board.pieces(chess.QUEEN, chess.BLACK)])kingsq = sum([kingstable[i] for i in board.pieces(chess.KING, chess.WHITE)])

kingsq = kingsq + sum([-kingstable[chess.square_mirror(i)]

for i in board.pieces(chess.KING, chess.BLACK)])

At last, let’s calculate the** evaluation function** which will return the **summation** of the material scores and the individual scores for white and when it comes for black, let’s negate it.

**(As, favorable conditions for White = unfavorable conditions for Black)**

eval = material + pawnsq + knightsq + bishopsq + rooksq + queensq + kingsqif board.turn:

return eval

else:

return -eval

*Let’s summarize our evaluation function right now, with the help of the flowchart given below:*