gnugo/src/doc/using.texi

@menu
* Documentation::            Getting Documentation
* CGoban::                   Running GNU Go with CGoban
* Other Clients::            Other Clients
* Ascii::                    The Ascii Interface
* Emacs::                    GNU Go mode in Emacs
* GMP and GTP::              The Go Modem Protocol and Go Text Protocol
* Tournaments::              Computer Tournaments
* SGF Support::              The Smart Game Format
* Invoking GNU Go::          Command line options
@end menu

@node Documentation

@section Getting Documentation

You can obtain a printed copy of the manual by running @command{make
gnugo.pdf} in the @file{doc/}directory, then printing the resulting file. The
manual contains a great deal of information about the algorithms of GNU Go.

On platforms supporting info documentation, you can usually
install the manual by executing `make install' (running as
root) from the @file{doc/} directory. This will create a file
called @file{gnugo.info} (and a few others) and copy them into
a system directory such as @file{/usr/local/share/info}. You
may then add them to your info directory tree with the command
@command{install-info --info-file=[path to gnugo.info] --info-dir=[path to dir]}.
The info documentation can be read conveniently from within Emacs by executing
the command @command{Control-h i}.

Documentation in @file{doc/} consists of a man page @file{gnugo.6}, the 
info files @file{gnugo.info}, @file{gnugo.info-1}, ... and the 
Texinfo files from which the info files are built. The Texinfo
documentation contains this User's Guide and extensive information
about the algorithms of GNU Go, for developers.

If you want a typeset copy of the Texinfo documentation, you can
@command{make gnugo.dvi}, @command{make gnugo.ps}, or @command{make
gnugo.pdf} in the @file{doc/} directory. (@command{make gnugo.pdf} only
works after you have converted all .eps-files in the doc/ directory to
.pdf files, e.g. with the utility epstopdf.)

You can make an HTML version with the command @command{makeinfo --html
gnugo.texi}. If you have @command{texi2html}, better HTML documentation
may be obtained by @command{make gnugo.html} in the @file{doc/}
directory.

User documentation can be obtained by running @command{gnugo --help} 
or @command{man gnugo} from any terminal, or from the Texinfo
documentation.

Documentation for developers is in the Texinfo documentation, and in comments
throughout the source. Contact us at @email{gnugo@@gnu.org} if you are
interested in helping to develop this program.

@node CGoban
@section Running GNU Go via CGoban
@cindex CGoban

There are two different programs called CGoban, both written by
William Shubert. In this documentation, CGoban means CGoban 1.x,
the older program. You should get a copy with version number 1.12 
or higher.

CGoban is an extremely nice way to run GNU Go. CGoban provides a
beautiful graphic user interface under X Window System.

Start CGoban. When the CGoban Control panel comes up, select ``Go
Modem''. You will get the Go Modem Protocol Setup. Choose one (or
both) of the players to be ``Program,'' and fill out the box with the
path to @file{gnugo}. After clicking OK, you get the Game Setup
window.  Choose ``Rules Set'' to be Japanese (otherwise handicaps
won't work).  Set the board size and handicap if you want.

If you want to play with a komi, you should bear in mind that
the GMP does not have any provision for communicating the komi.
Because of this misfeature, unless you set the komi at the command
line GNU Go will have to guess it. It assumes the komi is 5.5 for
even games, 0.5 for handicap games. If this is not what you want,
you can specify the komi at the command line with the
@option{--komi} option, in the Go Modem Protocol Setup window.
You have to set the komi again in the Game Setup window, which
comes up next.

Click OK and you are ready to go.

In the Go Modem Protocol Setup window, when you specify the path to
GNU Go, you can give it command line options, such as @option{--quiet} to
suppress most messages. Since the Go Modem Protocol preempts standard
I/O other messages are sent to stderr, even if they are not error
messages. These will appear in the terminal from which you started
CGoban.

@node Other Clients
@section Other Clients
@cindex jago
@cindex quarry
@cindex qGo

In addition to CGoban (@pxref{CGoban}) there are a number of
other good clients that are capable of running GNU Go. Here
are the ones that we are aware of that are Free Software. This
list is part of a larger list of free Go programs that is maintained
at @url{http://www.gnu.org/software/gnugo/free_go_software.html}.

@itemize @bullet
@item Quarry (@url{http://home.gna.org/quarry/}) is a GPL'd
client that supports GTP.  Works under GNU/Linux and requires
GTK+ 2.x and librsvg 2.5.  Supports GNU Go as well as other
engines.  Can play not only Go, but also a few other board
games.
@item qGo (@url{http://sourceforge.net/projects/qgo/}) is a
full featured Client for playing on the servers, SGF viewing/editing,
and GNU Go client written in C++ for GNU/Linux, Windows and Mac OS X.
Can play One Color Go. Licensed GPL and QPL.
@item ccGo (@url{http://ccdw.org/~cjj/prog/ccgo/}) is a GPL'd client
written in C++ capable of playing with GNU Go, or on IGS.
@item RubyGo (@url{http://rubygo.rubyforge.org/}) is a GPL'd
client by J.-F. Menon for IGS written in the scripting language Ruby.
RubyGo is capable of playing with GNU Go using the GTP.
@item Dingoui (@url{http://dingoui.sourceforge.net/}) is a free
GMP client written in GTK+ which can run GNU Go.
@item Jago (@url{http://www.rene-grothmann.de/jago/})
is a GPL'd Java client which works for both Microsoft Windows
and X Window System.
@item Sente Software's FreeGoban 
(@url{http://www.sente.ch/software/goban/freegoban.html}) is a
well-liked user interface for GNU Go (and potentially other
programs) distributed under the GPL.
@item  Mac GNU Go (@url{http://www1.u-netsurf.ne.jp/~future/HTML/macgnugo.html}) is a front end for GNU Go 3.2 with both
English and Japanese versions. License is GPL.
@item Quickiego (@url{http://www.geocities.com/secretmojo/QuickieGo/}) 
is a Mac interface to GNU Go 2.6.
@item Gogui (@url{http://sourceforge.net/projects/gogui/}) from
Markus Enzenberger is a Java workbench that allows you to play
with a gtp (@url{http://www.lysator.liu.se/~gunnar/gtp})
engine such as GNU Go. Licence is GPL. Gogui does not 
support gmp or play on servers but is potentially very useful for programmers
working on GNU Go or other engines.
@end itemize

@node Ascii
@section Ascii Interface
@cindex ascii interface

Even if you do not have any client program, you can play with GNU Go
using its default Ascii interface. Simply type @command{gnugo}
at the command line, and GNU Go will draw a board. Typing
@command{help} will give a list of options. At the end of the
game, pass twice, and GNU Go will prompt you through the
counting. You and GNU Go must agree on the dead groups---you
can toggle the status of groups to be removed, and when you
are done, GNU Go will report the score.

You can save the game at any point using the @command{save @var{filename}}
command. You can reload the game from the resulting SGF file with
the command @command{gnugo -l @var{filename} --mode ascii}. Reloading
games is not supported when playing with CGoban. However you can
use CGoban to save a file, then reload it in ascii mode.

You may play games with a time limit against GNU Go in
ascii mode. For this, the Canadian time control system
is used. (See @uref{http://en.wikipedia.org/wiki/Byoyomi}
and @uref{http://senseis.xmp.net/?CanadianByoyomi}.)
That is, you have a main time to be followed by byo-yomi
periods. After the main time is exhausted you have a certain
number of moves to be made in a certain number of seconds.
(@pxref{Invoking GNU Go})

@node Emacs
@section GNU Go mode in Emacs
@cindex emacs mode

You can run GNU Go from Emacs. This has the advantage 
that you place the stones using the cursor arrow keys
or with the mouse, and you can have a nice graphical display of the board
within emacs.

You will need the file @file{interface/gnugo.el}. There is
a version of this distributed with GNU Go but it only
works with Emacs 21. Most Emacsen are Emacs 22 however.
Therefore you should get the latest version of
gnugo.el by Thien-Thi Nguyen, which you can find at
@uref{http://www.gnuvola.org/software/j/gnugo/} or
@uref{http://www.emacswiki.org/emacs/gnugo.el}.

You will also need some xpm files for the graphical
display. You can either use those distributed by
Thien-Thi Nguyen (at the first URL above) or those
distributed with GNU Go, either the file
@file{interface/gnugo-xpms.el} or (for high resolution
displays) @file{interface/gnugo-big-xpms.el}.

Load the file @file{interface/gnugo.el} and 
@file{interface/gnugo-xpms.el}. You may do this using the 
Emacs @command{M-x load-file} command.

When you start a game with @command{M-x gnugo},
you will first see an ascii board. However typing `i'
toggles a graphical board display which is very nice.
This is a pleasant way to play GNU Go. You may get
help by typing @command{C-x m}.

@node GMP and GTP
@section The Go Modem Protocol and Go Text Protocol
@cindex GMP
@cindex GTP
@cindex The Go Modem Protocol and Go Text Protocol

@paragraphindent 3
The Go Modem Protocol (GMP) was developed by Bruce Wilcox with input from
David Fotland, Anders Kierulf and others, according to the history in
@url{http://www.britgo.org/tech/gmp.html}.

Any Go program @emph{should} support this protocol since it is a
standard. Since CGoban supports this protocol, the user interface for
any Go program can be done entirely through CGoban. The programmer can
concentrate on the real issues without worrying about drawing stones,
resizing the board and other distracting issues.

GNU Go 3.0 introduced a new protocol, the Go Text Protocol
(@pxref{GTP}) which we hope can serve the functions currently 
used by the GMP. The GTP is becoming increasingly adopted by
other programs as a method of interprocess communication,
both by computer programs and by clients. Still the GMP is 
widely used in tournaments.

@node Tournaments

@section Computer Go Tournaments

Computer Tournaments currently use the Go Modem Protocol.
The current method followed in such tournaments is to connect
the serial ports of the two computers by a ``null modem'' cable.
If you are running GNU/Linux it is convenient to use CGoban.
If your program is black, set it up in the Go Modem Protocol
Setup window as usual. For White, select ``Device'' and set
the device to @file{/dev/cua0} if your serial port is COM1
and @file{/dev/cua1} if the port is COM2.

@node SGF Support
@section Smart Game Format
@cindex SGF (Smart Game Format)
@cindex Smart Game Format

The Smart Game Format (SGF), is the standard format for storing Go games. 
GNU Go supports both reading and writing SGF files. The SGF specification
(FF[4]) is at:
@url{http://www.red-bean.com/sgf/}

@node Invoking GNU Go
@section Invoking GNU Go: Command line options
@cindex command line options
@cindex invoking GNU Go

@subsection Some basic options
@itemize
@item @option{--help}, @option{-h}
@quotation
Print a help message describing the options. This will also
tell you the defaults of various parameters, most importantly
the level and cache size. The default values of these
parameters can be set before compiling by @command{configure}.
If you forget the defaults you can find out using @option{--help}.
@end quotation
@item @option{--boardsize @var{size}}
@quotation
Set the board size
@end quotation
@item @option{--komi @var{num}}
@quotation
Set the komi
@end quotation
@item @option{--level @var{level}}
@cindex level of play
@quotation
GNU Go can play with different strengths and speeds. Level 10
is the default. Decreasing the level will make GNU Go faster
but less accurate in its reading.
@end quotation
@item @option{--quiet}, @option{--silent}
@quotation
Don't print copyright and other messages. Messages specifically
requested by other command line options, such as @option{--trace},
are not supressed.
@end quotation
@item @option{-l}, @option{--infile @var{filename}}
@quotation
Load the named SGF file. GNU Go will generate a move for
the player who is about to move. If you want to override this
and generate a move for the other player you may add the
option @option{--color @var{<color>}} where @var{<color>} is
@code{black} or @code{white}.
@end quotation
@item @option{-L}, @option{--until @var{move}}
@quotation
Stop loading just before the indicated move is played. @var{move} can
be either the move number or location.
@end quotation
@item @option{-o}, @option{--outfile @var{filename}}
@quotation
Write sgf output to file
@end quotation
@item @option{-O}, @option{--output-flags @var{flags}}
@quotation
Add useful information to the sgf file. Flags can be 'd', 'v' or
both (i.e. 'dv'). If 'd' is specified, dead and critical dragons
are marked in the sgf file. If 'v' is specified, move valuations
around the board are indicated.
@end quotation
@item @option{--mode @var{mode}} 
@quotation
Force the playing mode ('ascii', 'emacs,' 'gmp' or 'gtp'). The default is
ASCII, but if no terminal is detected GMP (Go Modem Protocol) will be
assumed. In practice this is usually what you want, so you may never
need this option.
@end quotation
@item @option{--resign-allowed}
@quotation
GNU Go will resign games if this option is enabled. This is the default unless
you build the engine with the configure option
@option{--disable-resignation-allowed}. Unfortunately
the Go Modem Protocol has no provision for passing a resignation,
so this option has no effect in GMP mode.
@end quotation
@item @option{--never-resign}
@quotation
GNU Go will not resign games.
@end quotation
@item @option{--resign-allowed}
@quotation
GNU Go will resign lost games. This is the default.
@end quotation
@end itemize

@subsection Monte Carlo Options

GNU Go can play Monte Carlo Go on a 9x9 board.  (Not
available for larger boards.) It makes quite a strong
engine. Here are the command line options.

@itemize
@item @option{--monte-carlo}
@quotation
Use Monte Carlo move generation (9x9 or smaller).
@end quotation
@item @option{--mc-games-per-level <number>}
@quotation
Number of Monte Carlo simulations per level. Default 8000.
Thus at level 10, GNU Go simulates 80,000 games in order
to generate a move.
@end quotation
@item @option{--mc-list-patterns}
@quotation
list names of builtin Monte Carlo patterns
@end quotation
@item @option{--mc-patterns <name>}
@quotation
Choose a built in Monte Carlo pattern database. The
argument can be @file{mc_mogo_classic}, @file{mc_montegnu_classic}
or @file{mc_uniform}.
@end quotation
@item @option{--mc-load-patterns <filename>}
@quotation
read Monte Carlo patterns from file
@end quotation
@end itemize

@subsection Other general options
@itemize
@item @option{-M}, @option{--cache-size @var{megs}} 
@quotation
@cindex cache-size
@cindex cache
Memory in megabytes used for caching of read results. The default size
is 8 unless you configure gnugo with the command @command{configure
--enable-cache-size=@var{size}} before compiling to make @var{size} the
default (@pxref{Installation}). GNU Go stores results of its reading
calculations in a hash table (@pxref{Hashing}). If the hash table is
filled, it is emptied and the reading continues, but some reading may
have to be repeated that was done earlier, so a larger cache size will
make GNU Go run faster, provided the cache is not so large that swapping
occurs. Swapping may be detected on GNU/Linux machines using the program
@command{top}. However, if you have ample memory or if performance seems
to be a problem you may want to increase the size of the cache using
this option.
@end quotation
@item @option{--chinese-rules}
@quotation
Use Chinese rules. This means that the Chinese or Area Counting is
followed. It may affect the score of the game by one point in even
games, more if there is a handicap (since in Chinese Counting the
handicap stones count for Black) or if either player passes during the
game.
@end quotation
@item @option{--japanese-rules} 
@quotation
Use Japanese Rules. This is the default unless you specify
@option{--enable-chinese-rules} as a configure option.
@end quotation
@item @option{--play-out-aftermath} 
@item @option{--capture-all-dead} 
@quotation
These options cause GNU Go to play out moves that are usually left
unplayed after the end of the game. Such moves lose points under
Japanese rules but not Chinese rules.  With
@option{--play-out-aftermath}, GNU Go may play inside its
territory in order to reach a position where it considers every
group demonstrably alive or dead. The option
@option{--capture-all-dead} causes GNU Go to play inside its own
territory to remove dead stones.
@end quotation
@item @option{--forbid-suicide} 
@quotation
Do not allow suicide moves (playing a stone so that it ends up without
liberties and is therefore immediately removed). This is the default.
@end quotation
@item @option{--allow-suicide} 
@quotation
Allow suicide moves, except single-stone suicide. The latter would not
change the board at all and pass should be used instead.
@end quotation
@item @option{--allow-all-suicide} 
@quotation
Allow suicide moves, including single-stone suicide. This is only
interesting in exceptional cases. Normally the
@option{--allow-suicide} option should be used instead.
@end quotation
@item @option{--simple-ko} 
@quotation
Do not allow an immediate recapture of a ko so that the previous
position is recreated. Repetition of earlier positions than that are
allowed. This is default.
@end quotation
@item @option{--no-ko} 
@quotation
Allow all kinds of board repetition.
@end quotation
@item @option{--positional-superko} 
@quotation
Forbid repetition of any earlier board position. This only applies to
moves on the board; passing is always allowed.
@end quotation
@item @option{--situational-superko} 
@quotation
Forbid repetition of any earlier board position with the same player
to move. This only applies to moves on the board; passing is always
allowed.
@end quotation
@item @option{--copyright}: Display the copyright notice
@item @option{--version} or @option{-v}: Print the version number
@item @option{--printsgf @var{filename}}: 
@quotation
Create an SGF file containing a diagram of the board. Useful with 
@option{-l} and @option{-L} to create a diagram of the board from
another sgf file. Illegal moves are indicated with the private
@code{IL} property.  This property is not used in the FF4 SGF
specification, so we are free to preempt it.
@end quotation
@item @option{--options}
@quotation 
Print which experimental configure options were compiled into the program
(@pxref{Other Options}).
@end quotation
@item @option{--orientation @var{n}}
@quotation
Combine with @option{-l}. The Go board can be oriented in 8 different
ways, counting reflections and rotations of the position; this option
selects an orientation (default 0). The parameter @samp{n} is an integer
between 0 and 7.
@end quotation
@end itemize

@subsection Other options affecting strength and speed

@itemize @bullet
@item @option{--level @var{amount}}
@cindex level
@quotation
The higher the level, the deeper GNU Go reads. Level 10 is the default.
If GNU Go plays too slowly on your machine, you may want to decrease it.
@end quotation
@end itemize

This single parameter @option{--level} is the best way of
choosing whether to play stronger or faster. It controls
a host of other parameters which may themselves be set
individually at the command line.  The default values of
these parameters may be found by running @command{gnugo --help}. 

Unless you are working on the program you probably don't
need the remaining options in this category. Instead,
just adjust the single variable @option{--level}. The
following options are of use to developers tuning the
program for performance and accuracy. For completeness,
here they are.

@itemize @bullet
@item @option{-D}, @option{--depth @var{depth}}
@cindex depth
@quotation
Deep reading cutoff. When reading beyond this depth (default 16) GNU
Go assumes that any string which can obtain 3 liberties is alive. Thus
GNU Go can read ladders to an arbitrary depth, but will miss other
types of capturing moves.
@end quotation
@item @option{-B}, @option{--backfill-depth @var{depth}}
@quotation
Deep reading cutoff. Beyond this depth (default 12) GNU Go will no 
longer try backfilling moves in its reading.
@end quotation
@item @option{--backfill2-depth @var{depth}}
@quotation
Another depth controlling how deeply GNU Go looks for backfilling
moves. The moves tried below @code{backfill2_depth} are generally more obscure
and time intensive than those controlled by @code{backfill_depth}, so this
parameter has a lower default.
@end quotation
@item @option{-F}, @option{--fourlib-depth @var{depth}}
@quotation
Deep reading cutoff. When reading beyond this depth (default 7) GNU
Go assumes that any string which can obtain 4 liberties is alive.
@end quotation
@item @option{-K}, @option{--ko-depth @var{depth}}
@quotation
Deep reading cutoff. Beyond this depth (default 8) GNU Go no longer
tries very hard to analyze kos.
@end quotation
@item @option{--branch-depth @var{depth}} 
@quotation
This sets the @code{branch_depth}, typically a little below the
@code{depth}. Between @code{branch_depth} and @code{depth},
attacks on strings with 3 liberties are considered but branching
is inhibited, so fewer variations are considered.  Below this
depth (default 13), GNU Go still tries to attack strings with only
3 liberties, but only tries one move at each node.
@end quotation
@item @option{--break-chain-depth @var{depth}}
@quotation
Set the @code{break_chain_depth}. Beyond this depth, GNU Go abandons
some attempts to defend groups by trying to capture part of the surrounding
chain.
@end quotation
@item @option{--aa-depth @var{depth}}
@quotation
The reading function @code{atari_atari} looks for combinations beginning
with a series of ataris, and culminating with some string having an
unexpected change in status (e.g. alive to dead or critical). This
command line optio sets the parameter @code{aa_depth} which determines
how deeply this function looks for combinations.
@end quotation
@item @option{--superstring-depth}
@quotation
A superstring (@pxref{Superstrings}) is an amalgamation of
tightly strings. Sometimes the best way to attack or defend a
string is by attacking or defending an element of the superstring.
Such tactics are tried below @code{superstring_depth} and this
command line option allows this parameter to be set.
@end quotation
@end itemize

The preceeding options are documented with the reading code
(@pxref{Reading Basics}).

@itemize @bullet
@item @option{--owl-branch} Below this depth Owl only considers
one move. Default 8.
@item @option{--owl-reading} Below this depth Owl assumes the
dragon has escaped.  Default 20.
@item @option{--owl-node-limit}
@quotation
If the number of variations exceeds this limit, Owl assumes the dragon can
make life. Default 1000. We caution the user that increasing
@code{owl_node_limit} does not necessarily increase the strength of the
program.
@end quotation
@item @option{--owl-node-limit @var{n}}
@quotation
If the number of variations exceeds this limit, Owl assumes the dragon can
make life. Default 1000.  We caution the user that increasing
@code{owl_node_limit} does not necessarily increase the strength of the
program.  
@end quotation
@item @option{--owl-distrust @var{n}}
@quotation
Below this limit some owl reading is truncated.
@end quotation
@end itemize

@subsection Ascii mode options
@cindex ascii mode

@itemize
@item @option{--color @var{color}}
@quotation
Choose your color ('black' or 'white').
@end quotation
@item @option{--handicap @var{number}}
@quotation
Choose the number of handicap stones (0--9)
@end quotation
@end itemize

For more information about the following clock options see @xref{Ascii}.

@itemize
@item @option{--clock @var{seconds}}
@quotation
Initialize the timer.
@end quotation
@item @option{--byo-time @var{seconds}}
@quotation
Number of seconds per (Canadian) byo-yomi period
@end quotation
@item @option{--byo-period @var{stones}}
@quotation
Number of stones per (Canadian) byo-yomi period
@end quotation
@end itemize

@subsection Development options

@itemize
@item @option{--replay @var{color}} 
@quotation
Replay all moves in a game for either or both colors. If used with the
@option{-o} option the game record is annotated with move values. This
option requires @option{-l @var{filename}}. The color can be:
@itemize
@item white: replay white moves only
@item black: replay black moves only
@item both: replay all moves
@end itemize
When the move found by genmove differs from the move in the sgf
file the values of both moves are reported thus:

@example
Move 13 (white): GNU Go plays C6 (20.60) - Game move F4 (20.60) 
@end example

This option is useful if one wants to confirm that a change such as a
speedup or other optimization has not affected the behavior of the
engine. Note that when several moves have the same top value (or
nearly equal) the move generated is not deterministic (though it can be
made deterministic by starting with the same random seed). Thus a few
deviations from the move in the sgf file are to be expected. Only if the
two reported values differ should we conclude that the engine plays
differently from the engine which generated the sgf file.
@xref{Regression}.
@end quotation
@item @option{-a}, @option{--allpats}
@quotation
Test all patterns, even those smaller in value than the largest move
found so far. This should never affect GNU Go's final move, and it
will make it run slower. However this can be very useful when "tuning"
GNU Go. It causes both the traces and the output file (@option{-o}) to
be more informative.
@end quotation
@item @option{-T}, @option{--printboard}: colored display of dragons.
@quotation
Use rxvt, xterm or Linux Console. (@pxref{Colored Display})
@end quotation
@item @option{--showtime}
@quotation
Print timing information to stderr.
@end quotation
@item @option{-E}, @option{--printeyes}: colored display of eye spaces
@quotation
Use rxvt, xterm or Linux Console. (@pxref{Colored Display})
@end quotation
@item @option{-d}, @option{--debug @var{level}}
@quotation
Produce debugging output. The debug level is given in hexadecimal, using the
bits defined in the following table from @file{engine/gnugo.h}. A list of
these may be produced using @option{--debug-flags}. Here they are in
hexadecimal:

@cindex debugging options
@example
  DEBUG_INFLUENCE             0x0001
  DEBUG_EYES                  0x0002
  DEBUG_OWL                   0x0004
  DEBUG_ESCAPE                0x0008
  DEBUG_MATCHER               0x0010
  DEBUG_DRAGONS               0x0020
  DEBUG_SEMEAI                0x0040
  DEBUG_LOADSGF               0x0080
  DEBUG_HELPER                0x0100
  DEBUG_READING               0x0200
  DEBUG_WORMS                 0x0400
  DEBUG_MOVE_REASONS          0x0800
  DEBUG_OWL_PERFORMANCE       0x1000
  DEBUG_LIFE                  0x2000
  DEBUG_FILLLIB               0x4000
  DEBUG_READING_PERFORMANCE   0x8000
  DEBUG_SCORING               0x010000
  DEBUG_AFTERMATH             0x020000
  DEBUG_ATARI_ATARI           0x040000
  DEBUG_READING_CACHE         0x080000
  DEBUG_TERRITORY             0x100000
  DEBUG_OWL_PERSISTENT_CACHE  0X200000
  DEBUG_TOP_MOVES             0x400000
  DEBUG_MISCELLANEOUS         0x800000
  DEBUG_ORACLE_STREAM         0x1000000
@end example

These debug flags are additive. If you want to turn on both
dragon and worm debugging you can use @option{-d0x420}.
@end quotation
@item @option{--debug-flags}
@quotation
Print the list of debug flags
@end quotation
@item @option{-w}, @option{--worms}
@quotation
Print more information about worm data.
@end quotation
@item @option{-m}, @option{--moyo @var{level}} 
@quotation
moyo debugging, show moyo board. The @var{level} is fully
documented elsewhere (@pxref{Influential Display}).
@end quotation
@item @option{-b}, @option{--benchmark @var{number}} 
@quotation
benchmarking mode - can be used with @option{-l}. Causes GNU Go to play itself
repeatedly, seeding the start of the game with a few random moves. This method
of testing the program is largely superceded by use of the @command{twogtp}
program.
@end quotation
@item @option{-S}, @option{--statistics}
@quotation
Print statistics (for debugging purposes).
@end quotation
@item @option{-t}, @option{--trace}
@quotation
Print debugging information. Use twice for more detail.
@end quotation
@item @option{-r}, @option{--seed @var{seed}}
@quotation
Set random number seed. This can be used to guarantee that GNU Go will make
the same decisions on multiple runs through the same game. If @code{seed} is
zero, GNU Go will play a different game each time.
@end quotation
@item @option{--decide-string @var{location}}
@quotation
Invoke the tactical reading code (@pxref{Tactical Reading} to decide
whether the string at @var{location} can be captured, and if so, whether it
can be defended. If used with @option{-o}, this will produce a variation tree
in SGF.
@end quotation
@item @option{--decide-owl @var{location}}
@quotation
Invoke the owl code (@pxref{The Owl Code}) to decide whether the dragon at
@var{location} can be captured, and whether it can be defended. If used with
@option{-o}, this will produce a variation tree in SGF.  
@end quotation
@item @option{--decide-connection @var{location1}/@var{location2}}
@quotation
Decide whether dragons at @var{location1} and @var{location2} can be connected.
Useful in connection with @option{-o} to write the variations to an SGF file.
@end quotation
@item @option{--decide-dragon-data @var{location}}
@quotation
Print complete information about the status of the dragon at @var{location}.
@end quotation
@item @option{--decide-semeai @var{location1}/@var{location2}}
@quotation
At @var{location1} and @var{location2} are adjacent dragons of the
opposite color. Neither is aliveby itself, and their fate (alive,
dead or seki) depends on the outcome of a semeai (capturing race).
Decide what happens.  Useful in connection with @option{-o} to
write the variations to an SGF file.
@end quotation
@item @option{--decide-tactical-semeai @var{location1}/@var{location2}}
@quotation
Similar to @option{--decide-semeai}, except that moves proposed by the
owl code are not considered.
@end quotation
@item @option{--decide-position}
@quotation
Try to attack and defend every dragon with dragon.escape<6. If
used with @option{-o}, writes the variations to an sgf file.
@end quotation
@item @option{--decide-eye @var{location}}
@quotation
Evaluates the eyespace at @var{location} and prints a report. You can get
more information by adding @option{-d0x02} to the command line. 
(@pxref{Eye Local Game Values}.)
@end quotation
@item @option{--decide-surrounded @var{location}}
@quotation
A dragon is @emph{surrounded} if it is contained in the convex hull of
its unfriendly neighbor dragons. This does not mean that it cannot escape,
but it is often a good indicator that the dragon is under attack. This
option draws the convex hull of the neighbor dragons and decides whether
the dragon at @var{location} is surrounded.
@end quotation
@item @option{--decide-combination}
@quotation
Calls the function @code{atari_atari} to decide whether there
exist combinations on the board.
@end quotation
@item @option{--score @var{method}}
@quotation
Requires @option{-l} to specify which game to score and @option{-L} if
you want to score anywhere else than at the end of the game record.
@var{method} can be "estimate", "finish", or "aftermath". "finish" and
"aftermath" are appropriate when the game is complete, or nearly so, and
both try to supply an accurate final score. Notice that if the game is
not already finished it will be played out, which may take quite a long
time if the game is far from complete. The "estimate" method may be used
to get a quick estimate during the middle of the game. Any of these
options may be combined with @option{--chinese-rules} if you want to use
Chinese (Area) counting.

If the option @option{-o @var{outputfilename}} is provided, the result
will also be written as a comment in the output file. For the "finish"
and "aftermath" scoring algorithms, the selfplayed moves completing the
game are also stored.

@itemize
@item finish
@quotation
Finish the game by selfplaying until two passes, then determine the
status of all stones and compute territory.
@end quotation
@item aftermath
@quotation
Finish the game by selfplaying until two passes, then accurately
determine status of all stones by playing out the "aftermath", i.e.
playing on until all stones except ones involved in seki have become
either unconditionally (in the strongest sense) alive or unconditionally
dead (or captured). Slower than @option{--score finish}, and while these
algorithms usually agree, if they differ, @option{--score aftermath} is
most likely to be correct.
@end quotation
@end itemize
@end quotation
@item @code{--score aftermath --capture-all-dead --chinese-rules}
@quotation
This combination mandates @strong{Tromp-Taylor} scoring. The
Tromp-Taylor ruleset requires the game to be played out until
all dead stones are removed, then uses area (Chinese) scoring.
The option @option{--capture-all-dead} requires the aftermath
code to finish capturing all dead stones.
@end quotation
@end itemize

@subsection Experimental options

Most of these are available as configure options and are
described in @ref{Other Options}.

@itemize @bullet
@item @option{--options}
@quotation 
Print which experimental configure options were compiled into the program.
@end quotation
@item @option{--with-break-in}
@item @option{--without-break-in}
@quotation
Use or do not use the experimental break-in code. This option
has no effect at level 9 or below. The break in code is enabled
by default at level 10, and the only difference between levels
9 and level 10 is that the break in code is disabled at level 9.
@end quotation
@item @option{--cosmic-gnugo}
@quotation
Use center oriented influence.
@end quotation
@item @option{--nofusekidb}
@quotation
Turn off the fuseki database.
@end quotation
@item @option{--nofuseki}
@quotation
Turn off fuseki moves entirely
@end quotation
@item @option{--nojosekidb}
@quotation
Turn off the joseki database.
@end quotation
@item @option{--mirror}
@quotation
Try to play mirror go.
@end quotation
@item @option{--mirror-limit @var{n}}
@quotation
Stop mirroring when @var{n} stones are on the board.
@end quotation
@end itemize