Recommended data format for describing the rules of chess

Question

I'm going to be writing a chess server and one or more clients for chess and I want to describe the rules of chess (e.g. allowable moves based on game state, rules for when a game is complete) in a programming language independant way. This is a bit tricky since some of the chess rules (e.g. King Castling, en passent, draws based on 3 or more repeated moves) are based not only on the board layout but also on the history of moves.

I would prefer the format to be:

• textual
• human readable
• based on a standard (e.g. YAML, XML)
• easily parsable in a variety of languages

But I am willing to sacrifice any of these for a suitable solution.

My main question is: How can I build algorithms of such a complexity that operate on such complex state from a data format?

A followup queston is: Can you provide an example of a similar problem solved in a similar manner that can act as a starting point?

Edit: In response to a request for clarity -- consider that I will have a server written in Python, one client written in C# and another client written in Java. I would like to avoid specifying the rules (e.g. for allowable piece movement, circumstances for check, etc.) in each place. I would prefer to specify these rules once in a language independant manner.

Answer 1

Let's think. We're describing objects (locations and pieces) with states and behaviors. We need to note a current state and an ever-changing set of allowed state changes from a current state.

This is programming. You don't want some "meta-language" that you can then parse in a regular programming language. Just use a programming language.

Start with ordinary class definitions in an ordinary language. Get it all to work. Then, those class definitions are the definition of chess.

With only miniscule exceptions, all programming languages are

• Textual
• Human readable
• Reasonably standardized
• Easily parsed by their respective compilers or interpreters.

Just pick a language, and you're done. Since it will take a while to work out the nuances, you'll probably be happier with a dynamic language like Python or Ruby than with a static language like Java or C#.

If you want portability. Pick a portable language. If you want the language embedded in a "larger" application, then, pick the language for your "larger" application.

---

Since the original requirements were incomplete, a secondary minor issue is how to have code that runs in conjunction with multiple clients.

1. Don't have clients in multiple languages. Pick one. Java, for example, and stick with it.

2. If you must have clients in multiple languages, then you need a language you can embed in all three language run-time environments. You have two choices.

   • Embed an interpreter. For example Python, Tcl and JavaScript are lightweight interpreters that you can call from C or C# programs. This approach works for browsers, it can work for you. Java, via JNI can make use of this, also. There are BPEL rules engines that you can try this with.

   • Spawn an interpreter as a separate subprocess. Open a named pipe or socket or something between your app and your spawned interpreter. Your Java and C# clients can talk with a Python subprocess. Your Python server can simply use this code.