News

• Go through this checklist before submitting your code.
• There was a critical bug in the PPlayer class in the method getLegalMoves. Many students had corrected the bug in their own submissions. An updated PPlayer.java file is here. The main download archive is also updated.
• There was a bug in the PBoard class. An updated PBoard.java file is here. The main download archive is also updated.
• Javadocs are now available here. Check out the methods of the PBoard class.
• A sample greedy player is available here. It shows how to clone a board and apply a move to get to the next state.
• Submission instructions are updated.

Goal

• The game
• The client/server software
• Implementing a player
• Advice
• Requirements and evaluation
• Submission instructions

The game is played on an 8x8 chessboard. There are two types of pieces on the board. Pushers (larger in size) and pushees. The game starts with one row of pushers behind a row of pushees for each player. The goal of the game is to reach the other side of the board with one of your pieces.

Download the Java server and client software here.

During the tournament, the game will be played with each player running on a different computer (to avoid contention for CPU). The players will communicate with the server via TCP socket connections. Of course, the server and clients can all be run on the same machine too.

The server and an example client are provided. Please see the README.txt file for a description of the included files.

To run a server and two random players on the local machine:

1. Download and extract the code. In the directory containing the code, compile with

      javac boardgame/*.java pushers/*.java 

2. Launch a server to listen on port 8123:

      java boardgame.Server -p 8123

   The server GUI appears.
3. In a different console, launch the first player to connect with:

      java boardgame.Client pushers.PRandomPlayer localhost 8123  

4. In yet another console, launch the second player:

      java boardgame.Client pushers.PRandomPlayer localhost 8123  

The server software also allows for locally running clients to be launched from the GUI (using the Lunch menu), for humans to play against software players or other humans, and for game log files to be viewed.

See the README.txt file for more information on running the client and server.

A framework is provided to help you implement your player. It handles communication with the server and maintains a copy of the current game board. You are also provided with the source code for a simple random player (the class pushers.PRandomPlayer), which you may use as a starting point.

To implement a player, create a class that impelments pushers.PPlayer. You need only define two methods:

1. a default constructor which MUST include your McGill ID
2. the chooseMove() method

A simple player will look like this:

////////////////////////////////////////////////////////////////////////
package mypackage;

import pushers.PPlayer;

public class MyPlayer extends PPlayer {
   
    /** A default constructor is needed so that the client 
    software can create a MyPlayer object. */
    public MyPlayer() {
        // The string passed to the Player constructor will be 
        // used to identify the player to the server. In your 
        // final version, this should be your McGill ID. 
        super("MY-MCGILL-ID"); 
    }
    
    /** Choose a move to play */
    public Move chooseMove(Board theboard) {
        // Pick a move to play somehow...      
        return move;
    }
} 
////////////////////////////////////////////////////////////////////////

    java boardgame.Client mypackage.MyPlayer localhost 8123  

Documentation:
The boardgame.Player and pushers.PPlayer classes also provides other methods. See the source code for boardgame.Player, pushers.PBoard and pushers.PPlayer for further documentation.

You are not required to use the provided PBoard and PMove classes in your code. It may be preferable to represent the board in a way better adapted to the particular algorithms you will use, since these classes were written with the server in mind. In fact, you are not required to use any of the client software provided as long as your player correctly communicates with the server and runs on the SOCS lab machines. Java remains the recommended language, but use whatever you are most comfortable with. (If you're mainly worried about performance, do some research before making a decision.) You are reminded that your code must run on Linux; if you have any special requirements, ask.

Some hints on writing a winning player:

1. Play the game against the random player, your player and/or other people to get a feel for the strategy required.
2. Start small and build up your player incrementally. Here is a natural progression of steps:
   • Figure out an evaluation function for board positions.
   • Encode a minimax-like algorithm with fixed depth (or iterative deepening).
   • Insert alpha-beta pruning.
   • Add whatever other heuristics you think may help.
   • Devise ways to tune the heuristics, manually or, better yet, using learning.
3. Test your code after each significant change. Make sure you always have a working program.
4. Experiment to see what effect your changes have. Leave yourself time for tweaking your player and trying out different approaches.
5. Ask questions if you
   • have trouble understanding the provided code,
   • need help getting started,
   • get stuck,
   • are wondering if your ideas will work,
   • or have any existential questions.

What to submit:

1. An implementation of your player program.
2. A written report documenting your approach. (Required for the final submission)

Special files:

1. A README.txt file which includes any extra requirements or necessary information about your code.
2. A runclient.sh script that runs you player. For players implemented in java, there is a sample script provided in the package. Make sure you change the name to run your player instead of the random player. This will help us automate the tournament.

Due date:

Language:

Limitations:

1. Intel Core(TM)2 Duo CPU @ 2.40GHz
2. 2G RAM
3. Running 32 bit Linux

Report:

1. An explanation of how your program works, and a motivation for your approach.
2. A brief description of the theoretical basis of the approach (about a half-page, in most cases); references to the text of other documents, such as the textbook, are appropriate but not absolutely necessary. If you use algorithms from other sources, briefly describe the algorithm and give a citation to your source.
3. A summary of the advantages and disadvantages of your approach, expected failure modes, or weaknesses of your program.
4. If you tried other approaches during the course of the project, summarize them briefly and discuss how they compared to your final approach.
5. A brief description (max. half page) of how you would go about improving your player (e.g. by introducing other AI techniques, changing internal representation etc.).

Tournament:

Academic integrity:
This is an individual project. The exchange of ideas regarding the game is encouraged, but sharing of code and reports is forbidden and will be treated as cheating. Please see the syllabus and www.mcgill.ca/integrity for more information.

All the players will be tested against the random player before the tournament and we will try to contact you if we have trouble running your player. If you have any special requirements (e.g. persistent data), include them in your email in addition to mentioning it in your README file.