Enter Your Reply

The main probem is not to devise a standard, but to get everyone to use it.
And in interfacing one medum with another, the problem of how to represent
the moves is a serious, but at the same time totally insignificant fraction
of the problem.

Take for example the Game-Courier server. Its main function is to allow
people to play games using a browser as client. Now we don't control what
browsers do, so the GC server has to adapt to the browser and send web
pages (i.e. html code). This html code does not only contain the current
move, but a graphical display of the board position (a FEN would certainy
not do), the game history, graphics to explain the pieces, text to explain
the rules, control elements to allow the user to step through the game
history, etc. To get an idea what the GC server sends FOR EVERY MOVE, click
'View -> Source' in the browser menu while ou are logged in to GC.

Now other game-play servers, even if they play through a browser like GC
(and not through a specially downloaded client, like Internet Chess
Servers, or through browser-loaded Java clients that use a dedicated TCP
channel, like the Unspeakble server), will use completely differently
formatted webpages, and might even use differently formatted webpages for
each game they provide. Having standardized moves somewhere on those pages
solves nothing. (Well, 0.1% of the problem, maybe.) The main problem is to
identify the current move on such a huge web-page of unspecfied layout.

To standardize the entire page would require most websites to give up the
looks that define their identity, and you can be sure they will never do
it. In addition, for merely exchanging the moves with an automated entity
(rather than a Human using a browser), the entire webpages that are used
now are extremely cumbersome, as 99% or more of what they contain is
redundant information. The logical solution would be that websites like the
GC server would provide, for each ongoing game, a separate access channel
designed for automated play.

Such an auxiliary 'web page' might contain nothing but the move. And it
does not even have to be in html format, as it is not intended for browser
viewing. It could even be a binary file, although I would not recommend
that. The most logical choice would be a text file, that would contain
nothing but the move, or (to allow viewers to come in during the game) the
list of all moves so far. In fact something very similar to the format I use in
the move.txt file that my Javascript viewer periodically downloads, when I
am broadcasting the comp-comp games going on in my PC. (See http://home.hccnet.nl/h.g.muller/goths.html )

Of course all the GUIs you would want to interface to would have to be
modified to become able to use this channel, and understand the format
that it uses. No GUI I know does load webpages over the internet. They all
open permanent TCP links to the server, as this offers two-way
communication, which is much more efficient. (You don't have to
incessantly poll the server to see if your opponent moved, but can wait
idly until the server sends you the move.)

Furthermore, note that Zillions of Games does not use a true GUI, as it is
not capable of handling automated play between two different engines. In
fact there is no way at all Zillions can communicate its moves to the
outside world, apart from the outside world staring to the computer
display and doing the image processing to interpret what it sees. ChessV
does not have any GUI-engine separation at all, it is an integrated
program, and not capable of playing games against entities that cannot
look to the display either. Gregory has told me that the next version of
ChessV will be a pure engine for running under WinBoard, though. As to
Zillions: there exists an adaptor to use the Zillions (semi-)GUI with a
WinBoard engine as AI, but not the inverse, which would allow you to use
the Zillions AI as a WinBoard engine. The makers of Zillions told me that
they are currently not contemplating of providing this capability, as they
ae not sure there is any demand for it. Of course the Zillions AI is quite
weak compared to dedicated engines, so setting it up for engine-engine
matches would likely only generate bad publicity for Zillions.

The only viable solution I see is that servers would provide an additional
channel geared for dedicated-client (GUI) based play, next to the
browser-based play they provide for Humans, and that a peudo-engine would
be developed that can run under a GUI as any other engine, but in stead of
thinking up moves, handle communication with the server. The logical choice
for communication between GUI and pseudo-engine would of course be WinBoard
protocol, as WinBoard is the only general purpose GUI that supports a wide
range of Chess variants. For communication with the servers, the whole
project would hinge on the willingness of game servers to provide the
auxilliary channel according to the adopted standard.