Requirements Document
 
Our goal is to release a working chess engine in Java, C++, and C# by April 24, 2003.

Team News:

March 25 Milestone met. (the protoype works!)

Everyone should download the Java code, run, and test it. Just download the newest versions of each of the five files and compile them.

March 20 Milestone met.

March 6 Milestone met.

We have basically started from scratch again as of March 1.

Meetings:

TBA
 
SUU CS 4200 - System Engineering Spring 2003
Class Chess Project Requirements Document
February 24th, 2003

Introduction
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.

Information Description
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 this project.

Functional Description
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 each.

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.

Validation Criteria
This project is to be considered completed when the following conditions are true:

  1. The chess engine is written in Java and compiled for the Linux and Windows platforms.
  2. The chess engine is written in C++ and compiled for the Linux and Windows platforms.
  3. The chess engine is written in C# and compiled for the Windows platform.
  4. All commands work as expected from either the command prompt or the WinBoard/XBoard interfaces.
  5. 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).
  6. 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.
  7. Code is correct in its syntax and usage.
  8. Classes of all three languages have implemented exactly the same search algorithm, so as to be fairly compared.
  9. 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.
  10. 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 report.
  11. 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.