negamax | negamax AI algorithm for turn-based games | Game Engine library

As I see it you have 2 questions which I will try to answer:

1. How can I add the time constraint function to this code so that it only returns the best move when the the mentioned time gets over and not before that.

So you want to search for a certain number of seconds each move instead of searching for a specific depth? This is very easy to implement, all you have to do is make the iterative deepening go to some large depth and then compare the current time with the search start time each x number of nodes. Something like this:

In a Negamax search with alpha beta you typically start with an infinite window (alpha=-inf, beta=inf). Then during search this window is narrowed due to the cut offs, which leads to either raising alpha, or lowering beta.

The flags indicate which type of node you have found. If you found a node within your search window (alpha < score < beta) this means you have an EXACT node. Lower bound means that score >= beta, and upper bound that the score <= alpha.

You can read more about it here, which is also a good page for finding all you need for chess programming.

Extracted information from here

Negamax is a simplification of MinMax by using the following property :

max(a,b) = -min(-a,-b)

So, instead of having a conditonnal value compute in minmax, which is the following:

On the second thought, the question is trivial :)

Indeed, if the child node value was too good to cause a beta-cutoff (value ≥ β), it means that parent node has move that is at lest good as value, but maybe there are some even better move. So the value is the LOWERBOUND for the exact node value.

value ≤ alphaOrig means that all moves was worse than alphaOrig. That means that value is the UPPERBOUND of consequences of all moves.

Lower and Upper are bounds of the value of the current node, not the root one, as I somehow implied.

Turn out I used the c limits

The correct function call ended up being -negamax(child, depth-1, −∞, +∞, -1), although the negamaxHandler function needed to be changed:

The answer to your question depends heavily on a few factors, such as how you are storing the chess board, and what your make/unmake move function looks like. I'm sure there are ways of storing the board that would be better suited towards your method, and indeed historically some top tiered chess engine (in particular crafty) used to use that method, but you are correct in saying that modern engines no longer do it that way. Here is a link to a discussion about this very point: http://www.talkchess.com/forum/viewtopic.php?t=50805

If you want to understand why this is, then you must understand how today's engines represent the board. The standard implementation revolves around bitboards, and that requires 12- 64 bit integers per position, in addition to a redundant mailbox (array in non computer chess jargon) used in conjunction. Copying all that is usually more expensive than a good makeMove/unMakeMove function.

I also want to point out that a hybrid approach is also common. Usually make and unmake is used on the board itself, where as other information like en passant squares and castle rights are copied and changed like you suggested.

Check your stop condition.

You need :

There are two problems with the code that you presented:

When you are using postMessage from within main js into the WebWorker, you are passing the HitTemp object, and later on, in the WebWorker you assume, that if you set properties of that object, the the original object would be modified as well. By that I mean the following code: