Axololly.Chess.MoveGenerator 1.2.3

Chess Move Generator v1.2.3

Documentation is slowly progressing. You can check it out here, and make sure to leave positive feedback. ❤️

Statistics

Here are the current file statistics for this project:

I'm incredibly proud of how much I've written, how much I've learnt and how far I've come. It feels amazing to write this.

PGN Support

I added PGN support now, which you can find in PGN.cs, and use under the namespace Chess.PGN. Now you can read games in PGN format. Do note that some PGNs are raising draw errors, mostly under the three-fold repetition rule. I became aware of this issue after running my code through a set of 7,000 PGNs I found here. For my experiments, I took games from Viswanatan Anand and Alireza Firouzja, then ran them through a custom-made interpreter.

Inputs and Outputs

Both inputting PGNs to a returned Board struct and outputting a PGN from a given Board struct are supported. Of course, outputting a PGN from a board can now be performed under the .PGN property.

To input a PGN:

using Chess;
using Chess.PGN;

string examplePGN;

Board outputtedBoard = PGN.InterpretPGN(examplePGN);

And to output a PGN:

using Chess;
using Chess.PGN;

Board board;

// Option 1 (cleaner)
string outputPGN = board.PGN;

// Option 2 (raw)
string outputPGN = PGN.ConvertToPGN(board);

It's as easy as that.

Results

For Anand's game set, I got these results on an i5-4210U:

Found 4162 PGNs in 110 milliseconds.

Translated 4162 PGNs in 11032 milliseconds.
Successfully translated 4108 PGNs and failed translating 54 PGNs.

This results in 377 PGNs translated every second, or one PGN every 0.0027s.

All the fails were draw-related, which has already been explained above.

For Firouzja's game set, I got these results on the same CPU:

Found 3713 PGNs in 60 milliseconds.

Translated 3713 PGNs in 6589 milliseconds.
Successfully translated 3664 PGNs and failed translating 49 PGNs.

This results in 413 PGNs translated every second, or one PGN every 0.0024 seconds.

Fails are for the same reasons.

Inner Workings

It works using regex to identify the start and end of a PGN's body - it starts with 1. and ends with either 0-1, 1-0, or 1/2-1/2. Note that this may also be present in a [Result "..."] tag, so we need to make sure that there isn't a leading quotation mark.

These can easily be compiled into regex with:

// For start
@"1\.";

// For end
@"[^""]((0-1)|(1-0)|(1/2-1/2))";

However, note that this does blindly extract moves, so if you gave it:

1. e4 e5 1. Nc6

It would interpret this as:

["e4", "e5", "Nc6"]

Then proceed to translate the moves to long algebraic notation, lookup them in the generated legal moves based on criteria extracted from the move, for example, like:

• an "N" means it's a knight move, and this can be either a Piece.WhiteKnight or Piece.BlackKnight, which we check the .SideToMove property for.

• if there's no piece character, it's a pawn move. For which side? We use the .SideToMove property for this again.

• if rank differentiation is provided, search for a move where the start square's rank originates on that specified rank, written as the "target rank"

Usage

📝:wrench: Note: To use this, make sure you have .NET 8.0.

To start, include the Chess namespace. Then you can create a Board instance and go from there.

For extra information, here's a table of all the functions you'd be using, and what they do:

Example

using Chess;

class Program
{
    static void Main()
    {
        Board board = new();

        Console.WriteLine($"Board:\n{board}\n");
        Console.WriteLine($"Next moves: [{string.Join(", ", board.GenerateLegalMoves())}]");
    }
}

Result

Board:
r n b q k b n r
p p p p p p p p
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
P P P P P P P P
R N B Q K B N R

Next moves: [b1a3, b1c3, g1f3, g1h3, a2a3, b2b3, c2c3, d2d3, e2e3, f2f3, g2g3, h2h3, a2a4, b2b4, c2c4, d2d4, e2e4, f2f4, g2g4, h2h4]

Perft

I translated this file into a more readable JSON structure where each document looks like this:

{
    "FEN": "...",
    "Depths": {
        "1": "...",
        "2": "...",
        "3": "...",
        "4": "...",
        "5": "...",
        "6": "..."
    }
}

And in total, there are around 6,600 of these that you can use to verify that your engine returns the correct move counts.

If you want to perft test my own project, you can do it with the Perft and Perft960 classes, which have the available features: |Type|Method|Explanation| |:-|:-|:-| |Basic|.BasePerftTest()|Returns the number of counted nodes at the end of the function.| |Move-by-Move|.MoveByMovePerftTest()|Prints the move and number of counted nodes, returning the total at the end.| |Global|.GlobalPerftTest()|Prints the number of counted nodes until a given depth is reached.| |Output|.OutputPerftTest()|Redirects the console output into a file for further review.|

Thanks

Honestly, thank you to everyone in the Stockfish Discord server, from Analog Hors and her magic bitboards article, all the way to Disservin, who I already mentioned above for his code relating to en-passant moves.

It means a lot to me, knowing I've finally completed a project that frustrated me back when I started in June. I learnt a new language, made new friends, and, most importantly, had a lot of fun with this.

So proud of how far I've come. Time to celebrate! 🎉