minimax | thin layer for Meteor providing EJSON | Compression library

It's unclear whether you are trying to implement the Fail-hard or Fail-soft methods, but I think that it's the later. If so, then while i cannot test this for you, I think that this is what you want:

You would need your recursive function to return a TreeNode instance, not a Tree instance. The top level call will then return the root node, which should then be assigned to the root attribute of a single Tree instance.

I would also suggest creating an Edge class, so you can store the information about the move that was played in the parent board in order to get to the child board.

If I understand correctly you want to separate the minimax/alphabeta algorithm from the actual game rules, and first create the tree of states (specific to the game), and then feed that to a generic minimax/alphabeta algorithm which can then be ignorant about the game rules, and just focus on the information in the tree.

Here is an idea for an implementation:

Try this by replacing all \n with
and You can bind to dom directly using dangerouslySetInnerHTML as per your requirement.

You seem to have lots of unnecessary functions and your minimax code looks way too complicated than it needs to be. Basically you need 4 main functions for your game:

• Minimax itself
• Get all possible moves from a position (unless you want to do the loop inside minimax)
• Determine if a player has won
• Determine if board is full

Also, have you looked at the pseudo code for minimax from e.g. Wikipedia? :

When a pygame program fails to call pygame.event.get() or pygame.event.pump() for a long time, the operating system thinks that the program is crashed.

There are important things that must be dealt with internally in the event queue. The main window may need to be repainted or respond to the system. If you fail to make a call to the event queue for too long, the system may decide your program has locked up.

From https://www.pygame.org/docs/ref/event.html#pygame.event.pump

If you make sure to call pygame.event.pump() occasionally in the minimax function, the OS won't think your program has crashed. So you'll be able to click on the window without getting "This window is not responding" or anything.

Hopefully this gets your problem, and it isn't something else.

By the way, I solved the problem 1h ago(posting it now). I forgot to reduce the depth value with every step taken towards the root of the tree. Just changed these parts:

1st:

Solution:

There were two bugs in my previous implementation:

1. Previously in the minValue function calculated the value for all 'legal actions' if there was only one ghost left. This is incorrect, you only have to calculate it once.

If you want to sort by distance to middle, you can use a lambda expression.

I will point out a few suggestions below to help you on the way if you are just getting started. First I just want to say that you are probably right that all moves get the same score and therefore it picks the first possible move. Try to add some Piece Square Tables (PST) to your Evaluation function and see if it puts pieces on appropriate squares.

1. I would implement a Negamax function instead of Minimax. It is way easier to debug and you won't have to duplicate a lot of code when you later make more optimizations. Negamax is one of the standard chess algorithms.
2. It seems like you don't do the legal move generation yourself, do you know how the board is represented in the library that you use? Instead of using the FEN for evaluation you want to use the board (or bitboards) to be able to do more advanced evaluation (more on it further down).
3. The min/max value of -105/105 is not a good way to go. Use -inf and inf instead to not get into troubles later on.

Regarding the evaluation you normally use the board representation to figure out how pieces are placed and how they are working together. Chessprogramming.org is a great resource to read up on different evaluation concepts.

For your simple starting evaluation you could just start with counting up all the material score at the beginning of the game. Then you subtract corresponding piece value when a piece is captured since that is the only case where the score is changing. Now you are recalculating lots of things over and over which will be very slow.

If you want to add PST to the evaluation then you also want to add the piece value change for the moving piece depending on the old and new square. To try and sum up the evaluation:

1. Sum up all piece values at start-up of a game (with PST scores if you use them) and save it as e.g. whiteScore and blackScore
2. In your evaluation you subtract the piece value from the opponent if you capture a piece. Otherwise you keep score as is and return it as usual.
3. If using PST you change the own score based on the new location for the moved piece.

I hope it makes sense, let me know if you need any further help.