chess.js | TypeScript chess library for chess move generation | Runtime Evironment library

I simply added the code for the buttons at the bottom of your code. This code attaches event handlers to the start and clear buttons, so it could be placed anywhere outside of a function. Here's some code to display the two buttons below the board. I also added some code to run the code inside the code snippet.

NOTE This is an architecture rather than a programming question and discouraged on stack overflow.

The website and gRPC service may be hosted on the same server (as you're doing locally). You have the flexibility in running both processes (website and gRPC service) on a single more powerful host or separately on two hosts.

NOTE Although most often gRPC communicates over TCP sockets, it is possible to use UNIX sockets and even buffered memory too.

If you run both processes on a single host, you will want to consider connecting the website to the gRPC service via localhost (127.0.0.1 or the loopback device). Using localhost, network traffic doesn't leave the host.

If you run both processes on different hosts, traffic must travel across a network. This is slower and will likely incur charges when hosted.

You will want to decide whether the gRPC service should be exposed to any network traffic other than your website. In many cases, a gRPC service is used to provide an API to facilitate integration by 3rd-parties. If you definitely don't want the gRPC service accessed by other things, then you'll want to ensure either that it's bound to localhost (see above; and thereby inaccessible to anything other than other processes e.g. your website on the host) or firewalled such that only the website is permitted to send traffic to it.

You can find cheap hosting of virtual machines (VMs) and you'll likely want to consider hosting both processes on a single VM, ensure that you constrain the resources that you pay for and that you secure traffic (as above).

You may wish to consider containerizing the application. In this case, while it's possible to run both processes in a single container, this is considered not good practice. You should thus consider 2 containers (website and gRPC server). Many hosting|cloud platforms provide container hosting and this is generally easier than managing VMs (since you don't need to patch|update the OS and any dependencies). If you can find a platform that accepts a Docker Compose describing or a Kubernetes Deployment in which you describe both your services and how they interact such that the gRPC service is only accessible to the website, that could be ideal.

You need to use the import syntax and to call new Chess() in mounted().

Does passing chess object in your imported function work for you?

In your utitilies.js

I played around a bit and I was able to use this to get it to work. This is around line 90 of your code. It uses your code to check if the move is not the correct one and resets it back until you do the correct move

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.

As their documentation says here, you can pass options such as newline_char in chess.pgn() to decide what to add before every new line. You can pass \n which adds a new line in the </code> to show moves in a new line.</p>

Based on the documentation at https://github.com/jhlywa/chess.js/blob/master/README.md#moves-options-, the flags are not passed into moves(), but rather, are returned from moves() as an attribute associated with each legal move. Therefore, to get a list of all captures, you will need to apply a filter on the resulting array of all legal moves. Something along the following lines...

The first argument is the board itself with the first 8 characters being row 8, then row 7 and so on. KQkq means white king can castle king side, w king q side, b king k side and b king q side respectively. So if it says only KQ it means only white king can castle king and queen side, black has lost its casting rights. - is no one can castle.

e3 means that e3 is the enpassant square. So if black had a pawn on d4 he could take the e4 pawn e.p. and end up on e3 square. - means there is no enpassant possible square (no side made a double pawn push).

The last 2 numbers are half move and move counter, the first one used to keep track of 50 move rule.

Read more here if you are interested: https://en.m.wikipedia.org/wiki/Forsyth–Edwards_Notation