SUU CS 4200 - System Engineering Spring 2003
Class Chess Project Requirements Document
February 24th, 2003
Our class project is to implement a chess-playing algorithm using
three different programming languages: Java, C++, and C#, for both
the Linux and Windows platforms if the languages allow. Performances
of these engines are to then be measured in terms of processed nodes
per second. The final product delivered to the customer will consist
of the source code, compiled executables, and a report that compares
and discusses the languages used for the engine as well as a discussion
of the tests run and their results. All this should be done and in
the customer's hands by Monday, April 28th, 2003 at 11:59am.
The following document contains an Information Description,
a Functional Description, and Validation Criteria.
This program will use the standard WinBoard/XBoard commands as its input
and output to the user, which should be a human, or optionally, the
computer using the same or different chess engines. These commands can
be entered and returned through standard input and output, which can
then optionally be processed by the WinBoard GUI. Only those bare essential
commands needed to play a simple game of chess is required to be implemented,
which is not all of the commands that the WinBoard standard entails.
If, however, it is easier to implement certain WinBoard protocol features
for the sake of saving time or supporting the required benchmarking
functions, then it is up to us, the development team, to decide which
to implement. No modification of the independent WinBoard/XBoard application
should be made.
Some specific inputs that the program should take are
the initial configuration commands that let you choose the positions
of the pieces on the board and which color the computer will play. It
should also have the ability to set the ply by which the engine will
search for the next best move. It should then output the generated move,
the result if the game has ended or a piece is captured, and finally
the measurement of nodes processed per second in the search algorithm
(we define a node in this context as a single iteration through the
move generation algorithm). In order to do this, the program must track
the time spent in generating the move, but it is not a requirement to
report this time.
Internal data that will be processed by the move generation
algorithm are the positions of the pieces on the board, point values
of pieces, and the total point value resulting from various moves. All
other commands, inputs, and outputs relevant to a standard chess engine,
as wise and helpful as they may be, are not explicit requirements of
As mentioned above, the final product should play a simple game of chess,
but with the added ability to capture performance, as measured by nodes
processed per second. This is accomplished by adding a special benchmark
function. The program does not need to have learning capacity, an opening
book function, or other advanced features that do not directly relate
to the core algorithm. While design is not restricted between the three
different implementations, the search algorithm must be identical for
In order to work properly and be tested for performance
speed, functions should be included that check moves for validity. The
program should also allow the game to be started and stopped at will,
allow the board to be configured in any possible way, and allow the
computer to play either side of the board.
The only other program that the chess engine will interact
with is the WinBoard/XBoard GUI, which is an existing application under
general public license, compiled into an executable. A human user can
use this application if desired, which will "pipe" commands
to and from the chess engine running from the same local directory.
This project is to be considered completed when the following conditions
The chess engine is written in Java and compiled
for the Linux and Windows platforms.
The chess engine is written in C++ and compiled
for the Linux and Windows platforms.
The chess engine is written in C# and compiled
for the Windows platform.
All commands work as expected from either the
command prompt or the WinBoard/XBoard interfaces.
Any board configuration may be tested, and
tests will return a precise number of nodes processed per second
in a reasonable amount of time ('reasonable' is for us to decide).
Code is easy to read because an agreed upon
standard for comment formatting, file naming, variable naming,
function naming, and control and data structure formatting has
been implemented consistently throughout classes.
Code is correct in its syntax and usage.
Classes of all three languages have implemented
exactly the same search algorithm, so as to be fairly compared.
A series of speed tests have been conducted
and recorded from various board configurations, and a narrative
of those tests compiled as part of the final report.
A comparison of languages, an analysis of our
experiences writing code with them, and a description of advantages
and disadvantages are all written up and included in the final
A final report with items 9 and 10 included,
along with the source code of each version of the program, and
copies of the compiled executables submitted in the form of a
CD and/or online website.