Chess is a great game. It’s even better if you’re good at it. Regrettably, I’ve never taken the time to learn chess strategy, so I decided to rely on the power of computation and game theory instead! As a fun side project, I have implemented a simple chess AI using JavaScript.

You can find the full source code for this tutorial in my GitHub repository.

The final product is playable here.

## Prerequisites

You should know basic programming and the general concept of a tree data structure. Everything else will be covered as part of this tutorial.

The two main algorithms involved are the minimax algorithm and alpha-beta pruning. These will be explained in-depth later on, and should be relatively simple to grasp if you have experience in programming.

## First Things First…

Getting the GUI and game mechanics out of the way. This allows us to direct our focus towards only the most fascinating aspect of the application: the decision-making (AI) part! For this, we will be using external libraries:

- chessboard.js handles the graphical interface, i.e. the chess board itself.
- chess.js handles the game mechanics, such as move generation / validation.

With these libraries, you should be able to create a working chess game by following the examples (5000 through 5005 in particular) on the chessboard.js website.

## Evaluation Function

Great! We have a functioning chessboard. But how do we implement an AI that plays (reasonably) good chess? Well, we’re going to need an evaluation function. Basically, we want to assign a ‘score’ to each chessboard instance (i.e. each set of positions of pieces on the board) so that our AI can make decisions on which positions are more favourable than other positions.

## A Zero-Sum Game

Chess is a zero-sum game. Any advantages gained by Player A implies disadvantages for Player B. Advantages can come in the form of capturing opponent pieces, or having pieces in favourable positions. Therefore, when assigning a score from our AI’s perspective, a positive score implies an overall advantage for our AI and disadvantage for its opponent, while a negative score implies an overall disadvantage for our AI and advantage for its opponent.

### A Simple Example

For instance, the score for the starting position is 0, indicating that neither side has an advantage yet. Later on into the game, we are faced with a decision between two moves: Move A and Move B. Let’s say Move A captures a queen, putting our score at 900, while Move B captures a pawn, putting our score at 100.

The AI will be able to compare between the two potential scenarios, and decide that Move A is the better move. Of course, this does not consider future ramifications — what if Move A gives our opponent the opportunity to attack? We will overcome this hurdle in the following sections by performing lookahead to anticipate subsequent moves.

### Piece Weights

The first aspect of our evaluation involves assigning weights to each piece type. If our AI plays from black’s perspective, any black pieces will add to our score, while any white pieces will subtract from our score, according to the following weights:

- Pawn: 100
- Knight: 280
- Bishop: 320
- Rook: 479
- Queen: 929
- King: 60,000

### Piece Square Tables

We now have a score based on which pieces exist on the board, but some positions are more favourable than others. For instance, positions that grant higher mobility should be more favourable. For this, we use *piece square tables *(PSTs), which assign an additional score delta to each piece based on its position on the board.

For instance, the PST for knights encourages moving to the center:

This is from white’s perspective, so it would have to be reflected for black.

I certainly am not a chess expert, so the piece weights and PST values are adapted from Sunfish.py. The following is my implementation of the evaluation function. Note that instead of iterating over 64 squares for each evaluation, we simply start from 0 and add or subtract from the score according to the latest move, keeping track of the previous score.

```
/*
* Piece Square Tables, adapted from Sunfish.py:
* https://github.com/thomasahle/sunfish/blob/master/sunfish.py
*/
var weights = { 'p': 100, 'n': 280, 'b': 320, 'r': 479, 'q': 929, 'k': 60000, 'k_e': 60000 };
var pst_w = {
'p':[
[ 100, 100, 100, 100, 105, 100, 100, 100],
[ 78, 83, 86, 73, 102, 82, 85, 90],
[ 7, 29, 21, 44, 40, 31, 44, 7],
[ -17, 16, -2, 15, 14, 0, 15, -13],
[ -26, 3, 10, 9, 6, 1, 0, -23],
[ -22, 9, 5, -11, -10, -2, 3, -19],
[ -31, 8, -7, -37, -36, -14, 3, -31],
[ 0, 0, 0, 0, 0, 0, 0, 0]
],
'n': [
[-66, -53, -75, -75, -10, -55, -58, -70],
[ -3, -6, 100, -36, 4, 62, -4, -14],
[ 10, 67, 1, 74, 73, 27, 62, -2],
[ 24, 24, 45, 37, 33, 41, 25, 17],
[ -1, 5, 31, 21, 22, 35, 2, 0],
[-18, 10, 13, 22, 18, 15, 11, -14],
[-23, -15, 2, 0, 2, 0, -23, -20],
[-74, -23, -26, -24, -19, -35, -22, -69]
],
'b': [
[-59, -78, -82, -76, -23,-107, -37, -50],
[-11, 20, 35, -42, -39, 31, 2, -22],
[ -9, 39, -32, 41, 52, -10, 28, -14],
[ 25, 17, 20, 34, 26, 25, 15, 10],
[ 13, 10, 17, 23, 17, 16, 0, 7],
[ 14, 25, 24, 15, 8, 25, 20, 15],
[ 19, 20, 11, 6, 7, 6, 20, 16],
[ -7, 2, -15, -12, -14, -15, -10, -10]
],
'r': [
[ 35, 29, 33, 4, 37, 33, 56, 50],
[ 55, 29, 56, 67, 55, 62, 34, 60],
[ 19, 35, 28, 33, 45, 27, 25, 15],
[ 0, 5, 16, 13, 18, -4, -9, -6],
[-28, -35, -16, -21, -13, -29, -46, -30],
[-42, -28, -42, -25, -25, -35, -26, -46],
[-53, -38, -31, -26, -29, -43, -44, -53],
[-30, -24, -18, 5, -2, -18, -31, -32]
],
'q': [
[ 6, 1, -8,-104, 69, 24, 88, 26],
[ 14, 32, 60, -10, 20, 76, 57, 24],
[ -2, 43, 32, 60, 72, 63, 43, 2],
[ 1, -16, 22, 17, 25, 20, -13, -6],
[-14, -15, -2, -5, -1, -10, -20, -22],
[-30, -6, -13, -11, -16, -11, -16, -27],
[-36, -18, 0, -19, -15, -15, -21, -38],
[-39, -30, -31, -13, -31, -36, -34, -42]
],
'k': [
[ 4, 54, 47, -99, -99, 60, 83, -62],
[-32, 10, 55, 56, 56, 55, 10, 3],
[-62, 12, -57, 44, -67, 28, 37, -31],
[-55, 50, 11, -4, -19, 13, 0, -49],
[-55, -43, -52, -28, -51, -47, -8, -50],
[-47, -42, -43, -79, -64, -32, -29, -32],
[ -4, 3, -14, -50, -57, -18, 13, 4],
[ 17, 30, -3, -14, 6, -1, 40, 18]
],
// Endgame King Table
'k_e': [
[-50, -40, -30, -20, -20, -30, -40, -50],
[-30, -20, -10, 0, 0, -10, -20, -30],
[-30, -10, 20, 30, 30, 20, -10, -30],
[-30, -10, 30, 40, 40, 30, -10, -30],
[-30, -10, 30, 40, 40, 30, -10, -30],
[-30, -10, 20, 30, 30, 20, -10, -30],
[-30, -30, 0, 0, 0, 0, -30, -30],
[-50, -30, -30, -30, -30, -30, -30, -50]
]
};
var pst_b = {
'p': pst_w['p'].slice().reverse(),
'n': pst_w['n'].slice().reverse(),
'b': pst_w['b'].slice().reverse(),
'r': pst_w['r'].slice().reverse(),
'q': pst_w['q'].slice().reverse(),
'k': pst_w['k'].slice().reverse(),
'k_e': pst_w['k_e'].slice().reverse()
}
var pstOpponent = {'w': pst_b, 'b': pst_w};
var pstSelf = {'w': pst_w, 'b': pst_b};
/*
* Evaluates the board at this point in time,
* using the material weights and piece square tables.
*/
function evaluateBoard (move, prevSum, color)
{
var from = [8 - parseInt(move.from[1]), move.from.charCodeAt(0) - 'a'.charCodeAt(0)];
var to = [8 - parseInt(move.to[1]), move.to.charCodeAt(0) - 'a'.charCodeAt(0)];
// Change endgame behavior for kings
if (prevSum < -1500)
{
if (move.piece === 'k') {move.piece = 'k_e'}
else if (move.captured === 'k') {move.captured = 'k_e'}
}
if ('captured' in move)
{
// Opponent piece was captured (good for us)
if (move.color === color)
{
prevSum += (weights[move.captured] + pstOpponent[move.color][move.captured][to[0]][to[1]]);
}
// Our piece was captured (bad for us)
else
{
prevSum -= (weights[move.captured] + pstSelf[move.color][move.captured][to[0]][to[1]]);
}
}
if (move.flags.includes('p'))
{
// NOTE: promote to queen for simplicity
move.promotion = 'q';
// Our piece was promoted (good for us)
if (move.color === color)
{
prevSum -= (weights[move.piece] + pstSelf[move.color][move.piece][from[0]][from[1]]);
prevSum += (weights[move.promotion] + pstSelf[move.color][move.promotion][to[0]][to[1]]);
}
// Opponent piece was promoted (bad for us)
else
{
prevSum += (weights[move.piece] + pstSelf[move.color][move.piece][from[0]][from[1]]);
prevSum -= (weights[move.promotion] + pstSelf[move.color][move.promotion][to[0]][to[1]]);
}
}
else
{
// The moved piece still exists on the updated board, so we only need to update the position value
if (move.color !== color)
{
prevSum += pstSelf[move.color][move.piece][from[0]][from[1]];
prevSum -= pstSelf[move.color][move.piece][to[0]][to[1]];
}
else
{
prevSum -= pstSelf[move.color][move.piece][from[0]][from[1]];
prevSum += pstSelf[move.color][move.piece][to[0]][to[1]];
}
}
return prevSum;
}
```

## Minimax

Now that we have an evaluation algorithm, we can start making intelligent decisions! We will use the minimax algorithm for this, and I highly recommend reading up on the Wikipedia article to better understand this decision strategy.

### Game Tree

We can represent chessboard positions as nodes in a game tree. Each node is a chessboard instance, and has children corresponding to the possible moves that can be taken from the parent node.

### Minimizing Losses

Essentially, minimax aims to minimize the possible losses, assuming both players are rational decision makers. We can represent the possible moves as a game tree, where each layer alternates between the maximizing and minimizing player. We are the maximizing player, attempting to maximize our score, while the opponent is the minimizing player, attempting to minimize our score.

At the leaf nodes, the evaluated score is backtracked. Positive and negative infinity are wins and losses respectively. At each recursive layer, the maximizing and minimizing roles are alternated. Layer 0 is the current game state, and the goal is to maximize our score.

### Alternate Moves

The question our AI has to answer is: “Out of all the possible moves at Layer 0, which guarantees the maximum score?”

This is the same as asking, “Assuming my opponent is always making the most optimal decisions, which move leads to the possibility of attaining the best possible score?”

If we want our AI to be any decent at chess, we would have to perform a lookahead to anticipate our opponent’s subsequent moves. Of course, we can only anticipate a couple turns in advance — it’s not computationally feasible to look ahead as far as the final winning or losing states. We will have to introduce a depth limit that corresponds to the number of turns we are willing to look ahead, and use our evaluation function to determine the favorability of game states once we reach the depth limit.

### The Algorithm

This is a fun recursion problem, and I recommend trying to implement it yourself, although my implementation can be found below. If you're stuck, here’s the general idea:

- We decide on a predetermined depth limit, k.
- At Layer 0, we consider each of our possible moves, i.e. child nodes.
- For each child node, we consider the minimum score that our opponent can force us to receive. Then, we choose the maximum node.
- But to know the minimum score that our opponent can force us to receive, we must go to Layer 1. For each node in Layer 1, we consider their child nodes.
- For each child node (possible move by our opponent), we consider the maximum score that we can achieve subsequently. Then, the minimum score that our opponent can force us to receive is the minimum node.
- But to know the maximum score that we can achieve subsequently, we must go to Layer 2.
- And so on…
- At Layer k, the final board state is evaluated and backtracked to Layer k - 1, and this continues until we reach Layer 0, at which point we can finally answer: “What is the optimal move at this point?”

Here’s my implementation. Note that I used a slightly modified version of chess.js, which allows me to use game.ugly_moves() and game.ugly_move() to generate and make moves without converting them to a human-readable format, improving the efficiency of the algorithm. The modified version can be found here, but using the normal game.moves() and game.move() will work just fine too.

```
/*
* Performs the minimax algorithm to choose the best move: https://en.wikipedia.org/wiki/Minimax (pseudocode provided)
* Recursively explores all possible moves up to a given depth, and evaluates the game board at the leaves.
*
* Basic idea: maximize the minimum value of the position resulting from the opponent's possible following moves.
*
* Inputs:
* - game: the game object.
* - depth: the depth of the recursive tree of all possible moves (i.e. height limit).
* - isMaximizingPlayer: true if the current layer is maximizing, false otherwise.
* - sum: the sum (evaluation) so far at the current layer.
* - color: the color of the current player.
*
* Output:
* the best move at the root of the current subtree.
*/
function minimax(game, depth, isMaximizingPlayer, sum, color)
{
positionCount++;
var children = game.ugly_moves({verbose: true});
// Sort moves randomly, so the same move isn't always picked on ties
children.sort(function(a, b){return 0.5 - Math.random()});
var currMove;
// Maximum depth exceeded or node is a terminal node (no children)
if (depth === 0 || children.length === 0)
{
return [null, sum]
}
// Find maximum/minimum from list of 'children' (possible moves)
var maxValue = Number.NEGATIVE_INFINITY;
var minValue = Number.POSITIVE_INFINITY;
var bestMove;
for (var i = 0; i < children.length; i++)
{
currMove = children[i];
// Note: in our case, the 'children' are simply modified game states
var currPrettyMove = game.ugly_move(currMove);
var newSum = evaluateBoard(currPrettyMove, sum, color);
var [childBestMove, childValue] = minimax(game, depth - 1, !isMaximizingPlayer, newSum, color);
game.undo();
if (isMaximizingPlayer)
{
if (childValue > maxValue)
{
maxValue = childValue;
bestMove = currPrettyMove;
}
}
else
{
if (childValue < minValue)
{
minValue = childValue;
bestMove = currPrettyMove;
}
}
}
if (isMaximizingPlayer)
{
return [bestMove, maxValue]
}
else
{
return [bestMove, minValue];
}
}
```

## Alpha-beta Pruning

Our AI should now be able to make reasonably good decisions. The higher the search depth, the better it will play. However, increasing the search depth drastically increases the execution time. Alpha-beta pruning helps to improve the algorithm’s efficiency by ‘pruning’ branches that we don’t need to evaluate. An additional reading resource can be found here.

### Core Idea

The core idea of alpha-beta pruning is that we can stop evaluating a move when at least one possibility has been found that proves the move to be worse than a previously examined move.

Suppose that the game tree is as follows:

For brevity, let’s consider the following subtree:

The maximizing player first considers the left child, and determines that it has a value of 5. Other paths will only be chosen if their value is x > 5.

Next, the right child is considered. The minimizing player, at the right child, has found the values 7 and 4 so far. But then this means that regardless of what the remaining value is, the minimizing player would end up with a minimum value of at most 4. We know the final value of this subtree would be x <= 4, regardless of the remaining value.

In order for this path to be relevant, x > 5. But we know that x <= 4. This is a contradiction, so the maximizing player wouldn’t choose this path and there is no point evaluating this path further.

### The Algorithm

The same idea can then be extended to the rest of the game tree. We use two variables, alpha and beta, to keep track of the maximizing and minimizing values (5 and 4 in the previous example) respectively. This only requires minor modifications to the previous minimax function — see if you can implement it yourself!

Here’s my implementation:

```
/*
* Performs the minimax algorithm to choose the best move: https://en.wikipedia.org/wiki/Minimax (pseudocode provided)
* Recursively explores all possible moves up to a given depth, and evaluates the game board at the leaves.
*
* Basic idea: maximize the minimum value of the position resulting from the opponent's possible following moves.
* Optimization: alpha-beta pruning: https://en.wikipedia.org/wiki/Alpha%E2%80%93beta_pruning (pseudocode provided)
*
* Inputs:
* - game: the game object.
* - depth: the depth of the recursive tree of all possible moves (i.e. height limit).
* - isMaximizingPlayer: true if the current layer is maximizing, false otherwise.
* - sum: the sum (evaluation) so far at the current layer.
* - color: the color of the current player.
*
* Output:
* the best move at the root of the current subtree.
*/
function minimax(game, depth, alpha, beta, isMaximizingPlayer, sum, color)
{
positionCount++;
var children = game.ugly_moves({verbose: true});
// Sort moves randomly, so the same move isn't always picked on ties
children.sort(function(a, b){return 0.5 - Math.random()});
var currMove;
// Maximum depth exceeded or node is a terminal node (no children)
if (depth === 0 || children.length === 0)
{
return [null, sum]
}
// Find maximum/minimum from list of 'children' (possible moves)
var maxValue = Number.NEGATIVE_INFINITY;
var minValue = Number.POSITIVE_INFINITY;
var bestMove;
for (var i = 0; i < children.length; i++)
{
currMove = children[i];
// Note: in our case, the 'children' are simply modified game states
var currPrettyMove = game.ugly_move(currMove);
var newSum = evaluateBoard(currPrettyMove, sum, color);
var [childBestMove, childValue] = minimax(game, depth - 1, alpha, beta, !isMaximizingPlayer, newSum, color);
game.undo();
if (isMaximizingPlayer)
{
if (childValue > maxValue)
{
maxValue = childValue;
bestMove = currPrettyMove;
}
if (childValue > alpha)
{
alpha = childValue;
}
}
else
{
if (childValue < minValue)
{
minValue = childValue;
bestMove = currPrettyMove;
}
if (childValue < beta)
{
beta = childValue;
}
}
// Alpha-beta pruning
if (alpha >= beta)
{
break;
}
}
if (isMaximizingPlayer)
{
return [bestMove, maxValue]
}
else
{
return [bestMove, minValue];
}
}
```

## Conclusion

That’s all! I hope you have enjoyed reading this article as much as I have enjoyed writing it. I’ve explained how I implemented my AI, and hopefully introduced several new and interesting concepts to you.

I’ve also implemented some other features, including pitting the AI against itself. You can play it at here, and refer to my GitHub repository for the implementation.