Before you can run this, you must install PLT Scheme v301.9,
available here:

  http://icfpc.cs.uchicago.edu/sc/

WINDOWS:

  Run these commands to generate the Tournament and Player
  executables:

    mzc --gui-exe Tournament tournament.scm
    mzc --gui-exe Player run-player.scm

  You will probably need to specify the complete path to
  mzc, which should be:
  "c:\Program Files\PLT Scheme v301.9\mzc".

MAC OS X, LINUX & OTHER UNIXES:

  Use the included `tournament' and `run-player' shell
  scripts to run the tournament and the players. They
  require that `mred' be on your path, so either add it, or
  edit the script to point directly to wherever mred is
  installed: "/Applications/PLT Scheme v301.9/bin/mred" for
  Mac OS X, and probably /usr/local/bin/mred for linux.


Once it is installed, start the tournament and connect (some
multiple of) five players to the server. When the server
gets five players, it starts a game with them.

Pass -h to the tournament and the player programs to see
what options are available.

============================================================

Robby's player: the player computes a numerical score for
each possible move, given a board, a tile to place, and a
number of meeples. The score is a weighted sum of the a
couple of different numbers:

  - the difference between the average this-move score for
    other players and my this-move score.

  - the difference between the average end-game score for
    other players and my end-game score, with a bonus for
    incomplete cities in fields each player controls. The
    bonus is a factor between 1 and 2. The fewer tiles
    needed to complete the city, the closer the bonus factor
    is to 2. If there are five or more tiles needed the
    factor is 1.

  - a measure of how complete the areas are (that my player
    controls). For each area, it finds all of the places
    where a tile could be placed around the area. It then
    takes the initial set of tiles, removes all of the tiles
    in the board and determines how many of those tiles
    would fit into each of those places, coming up with an
    approximation to the probability that the player will be
    able to play on that region

The stealing player uses the above numbers, but adds a
fourth number:

  - For each move that places a meeple in a city or a field,
    it finds the open areas around that city or field and
    attempts to place the remaining tiles there. It then
    scores that new board and for each of those boards,
    keeps the biggest difference between its score and the
    average score of the other players., ie the biggest
    potential payoff for stealing some region.

    Computing this number is fairly slow, since it is
    effectively looking two moves ahead.

Once it has those numbers, it uses a weighted sum of the
numbers to compute the score of this move and the move with
the highest score is played. The weights were discovered by
making some guesses about good weights and playing lots of
games against each other to see which weights won more.

If a timeout (9 seconds for the non-stealing player,
settable for the stealing player) is hit before considering
all of the possible moves, the player just returns the best
one of the ones it has looked at so far (and prints out how
many it failed to consider).