| 1 | |
| 2 | =head1 NAME |
| 3 | |
| 4 | gnugo - The GNU program to play the game of Go |
| 5 | |
| 6 | =head1 SYNOPSIS |
| 7 | |
| 8 | B<gnugo> |
| 9 | [B<--boardsize <num>>] |
| 10 | [B<--color <color>>] |
| 11 | [B<--handicap <num>>] |
| 12 | [B<--komi <num>>] |
| 13 | [B<--quiet>] |
| 14 | [B<-v, --version>] |
| 15 | [B<-h, --help>] |
| 16 | [B<--help debug>] |
| 17 | [B<--copyright>] |
| 18 | [B<--mode <mode>>] |
| 19 | [B<--replay <color>>] |
| 20 | [B<-l, --infile <filename>>] |
| 21 | [B<-L, --until <move>>] |
| 22 | [B<-o, --outfile <filename>>] |
| 23 | [B<--printsgf <filename>>] |
| 24 | [B<-D, --depth <num>>] |
| 25 | [B<-B, --backfill_depth <num>>] |
| 26 | [B<--score [estimate|finish|aftermath]> ] |
| 27 | [B<-a, --allpats>] |
| 28 | [B<-T, --printboard>] |
| 29 | [B<-d, --debug <level>>] |
| 30 | [B<-w, --worms>] |
| 31 | [B<-m, --moyo <level>>] |
| 32 | [B<-b, --benchmark num>] |
| 33 | [B<-t, --trace>] |
| 34 | [B<-r, --seed num>] |
| 35 | |
| 36 | =head1 DESCRIPTION |
| 37 | |
| 38 | GNU Go plays a game of Go against the user. It has many other features: it |
| 39 | can play against itself or another program, analyse and score a recorded |
| 40 | game. GNU Go is compliant with Go modem protocol, load and save game in |
| 41 | the Smart Game format. |
| 42 | |
| 43 | GNU Go default is a simple alpha-numeric board display, but you can use |
| 44 | a client such as B<CGoban>. |
| 45 | |
| 46 | =head2 The game of Go |
| 47 | |
| 48 | Go is a game of strategy between two players usually played on a |
| 49 | 19x19 grid called B<goban>. The two players put black and white B<stones> on |
| 50 | the goban to enclose B<territory>. Go was invented about 4000 years ago in |
| 51 | ancient China. Other names for this game are (Chinese) B<Wei Chi>, (Korean) |
| 52 | B<Baduk> and (Ing) B<Goe>. |
| 53 | |
| 54 | =head2 Playing a game in ASCII mode |
| 55 | |
| 56 | To start a game with default options, just invoke "gnugo". The board will be |
| 57 | drawn at your terminal using ASCII letters. In this mode, you can get help on |
| 58 | available commands by the B<h> key. To play as Black with 4 stones handicap, |
| 59 | with a 0.5 komi, recording the game in the file record.sgf: |
| 60 | |
| 61 | gnugo --color black --handicap 4 --komi 0.5 -o record.sgf |
| 62 | |
| 63 | =head2 Playing a game with CGoban |
| 64 | |
| 65 | CGoban is a general purpose client program by Bill Shubert for |
| 66 | playing Go. It runs under X Window System with a beautiful resizeable |
| 67 | graphic display. To use GNU Go under X Window System, obtain the |
| 68 | most recent version of CGoban from Bill Shubert's web site |
| 69 | |
| 70 | http://www.igoweb.org/~wms/comp/cgoban/index.html |
| 71 | |
| 72 | Start CGoban. When the CGoban Control panel comes up, select `Go Modem.' |
| 73 | You will get the Go Modem Protocol Setup. Choose one (or both) of the |
| 74 | players to be ``Program,'' and fill out the box to the path to |
| 75 | gnugo. After clicking OK, you get the Game Setup window. Choose |
| 76 | ``Rules Set'' to be Japanese (otherwise handicaps won't work). Set the |
| 77 | board size and handicap if you want. Click OK and you are ready to go. |
| 78 | |
| 79 | In the Go Modem Protocol Setup window, when you specify the path |
| 80 | to GNU Go, you can give it command line options, such as --quiet |
| 81 | to suppress most messages. Since the Go Modem Protocol preempts |
| 82 | standard I/O, other messages are sent to stderr, even if they are |
| 83 | not error messages. These will appear in the terminal from which |
| 84 | you started CGoban. |
| 85 | |
| 86 | =head2 Scoring system |
| 87 | |
| 88 | The game stops when both players pass. GNU Go will attempt to |
| 89 | compute and report the score to you. It may occasionally make |
| 90 | mistakes due to wrong evaluation of the status of a group. You |
| 91 | can check the score as follows. In ASCII mode, at the end of |
| 92 | the game, stones believed dead are marked in lower case letters, |
| 93 | and you have the option of toggling their status before counting. |
| 94 | Using CGoban, you may use CGoban's counting facility to count |
| 95 | the game using either Japanese or Chinese rules. |
| 96 | |
| 97 | =head2 Viewing a stored game |
| 98 | |
| 99 | gnugo B<-l> filename.sgf --mode ascii |
| 100 | |
| 101 | loads filename.sgf and lets you navigate through the game by using the |
| 102 | commands I<forward>, I<back>, I<goto> and I<last>. |
| 103 | It is not possible to navigate through variations in ascii mode. |
| 104 | You may also use CGoban to view stored games. CGoban can navigate |
| 105 | variations. |
| 106 | |
| 107 | =head2 Documentation |
| 108 | |
| 109 | The files in the F<doc> directory contain detailed documentation about |
| 110 | debugging options and internal program structure. Other documentation may |
| 111 | be found in comments throughout the source code. |
| 112 | |
| 113 | =head2 Go Modem Protocol |
| 114 | |
| 115 | The Go Modem Protocol is a standard interface between Go programs and |
| 116 | graphical display. |
| 117 | |
| 118 | The Go Modem Protocol was developed by Bruce Wilcox with input from |
| 119 | David Fotland, Anders Kierulf and others. Any Go program *should* |
| 120 | use this protocol since it is standard. Since CGoban supports this |
| 121 | protocol, the user interface for any Go program can be done |
| 122 | entirely through CGoban. Using the Go Modem Protocol, you can play |
| 123 | with another computer running a different program (even on a |
| 124 | different operating system) using a modem, a serial cable or over |
| 125 | the internet if the other program also supports the protocol. You |
| 126 | can also communicate with the Go servers using CGoban. |
| 127 | |
| 128 | =head2 Smart Game Format |
| 129 | |
| 130 | Games (with comments, variations and other features) can be |
| 131 | stored in the Smart Game Format (SGF). This format originated in |
| 132 | Anders Kierulf's program Smart Go. Martin Muller and Arno |
| 133 | Hollosi developed the current standard, which may be found |
| 134 | at |
| 135 | |
| 136 | http://www.red-bean.com/sgf/ |
| 137 | |
| 138 | GNU Go supports the Smart Game Format. |
| 139 | |
| 140 | =head1 OPTIONS |
| 141 | |
| 142 | =head2 Main options |
| 143 | |
| 144 | B<--mode I<mode>> |
| 145 | |
| 146 | force the playing mode (I<ascii'>, I<gtp> or I<gmp>). Default is |
| 147 | ASCII. If no terminal is detected GMP (Go Modem Protocol) will be assumed. |
| 148 | |
| 149 | B<--replay I<color>> |
| 150 | |
| 151 | replay the game generating moves for color, where color is I<white>, |
| 152 | I<black>, or I<both>. (requires B<-l>) |
| 153 | |
| 154 | B<--quiet> |
| 155 | |
| 156 | Don't print copyright and other informational messages. |
| 157 | |
| 158 | B<-l, --infile I<file>> |
| 159 | |
| 160 | Load the SGF file (to score or analyze a recorded game). |
| 161 | |
| 162 | B<-L, --until I<move>> |
| 163 | |
| 164 | Stop loading just before I<move> is played (e.g. 154 or L10). |
| 165 | |
| 166 | B<-o, --outfile I<file>> |
| 167 | |
| 168 | Save the played game to I<file> in SGF format. |
| 169 | |
| 170 | =head2 Game Options: |
| 171 | |
| 172 | B<--boardsize I<num>> |
| 173 | |
| 174 | Set the board size to use (1-19). Default is 19, other common formats are |
| 175 | 13 and 9. |
| 176 | |
| 177 | B<--color I<color>> |
| 178 | |
| 179 | Choose your color (I<black> or I<white>). Black plays first, White gets |
| 180 | the komi compensation. |
| 181 | |
| 182 | B<--handicap I<num>> |
| 183 | |
| 184 | Set the number of handicap stones. |
| 185 | |
| 186 | B<--komi I<num>> |
| 187 | |
| 188 | Set the komi (points given to white player to compensate advantage of the |
| 189 | first move, usually 5.5 or 0.5). Default is 5.5. |
| 190 | |
| 191 | =head2 Informative Output: |
| 192 | |
| 193 | B<-v, --version> |
| 194 | |
| 195 | Display the version of GNU Go. |
| 196 | |
| 197 | B<-h, --help> |
| 198 | |
| 199 | Display help message. |
| 200 | |
| 201 | B<--help debug> |
| 202 | |
| 203 | Display help about debugging options. |
| 204 | |
| 205 | B<--copyright> |
| 206 | |
| 207 | Display copyright notice. |
| 208 | |
| 209 | =head2 Debugging and advanced options: |
| 210 | |
| 211 | B<-T, --printboard> |
| 212 | |
| 213 | Show board each move. |
| 214 | |
| 215 | B<--level I<num>> |
| 216 | |
| 217 | Level of play. (default 10; smaller=faster, weaker). |
| 218 | |
| 219 | B<-b, --benchmark I<num>> |
| 220 | |
| 221 | Benchmarking mode - can be used with B<-l>. |
| 222 | |
| 223 | B<-t, --trace> |
| 224 | |
| 225 | Verbose tracing (use twice or more to trace reading). |
| 226 | |
| 227 | B<-r, --seed I<num>> |
| 228 | |
| 229 | Set random number seed. |
| 230 | |
| 231 | B<--score [I<estimate|finish|aftermath>]> |
| 232 | |
| 233 | Count or estimate territory of the input file. Usage: |
| 234 | |
| 235 | B<gnugo --score estimate -l filename> |
| 236 | |
| 237 | Loads the SGF file and estimates the score by measuring the |
| 238 | influence. Use with B<-L> if you want the estimate somewhere else than |
| 239 | at the end of the file. |
| 240 | |
| 241 | B<gnugo --score finish -l filename> |
| 242 | |
| 243 | Loads the SGF file and gnugo continues to play by itself up to the |
| 244 | very end. Then the winner is determined by counting the territory. |
| 245 | |
| 246 | B<gnugo --score aftermath -l filename> |
| 247 | |
| 248 | Similar to B<--score finish> except that a more accurate but slower |
| 249 | algorithm is used to determine the final status of the groups. |
| 250 | |
| 251 | If the option B<-o outputfilename> is provided, |
| 252 | the results will also be written as comment at the end of the output file. |
| 253 | |
| 254 | B<--printsgf I<outfile>> |
| 255 | |
| 256 | Load SGF file, output final position (requires B<-l>). |
| 257 | |
| 258 | =head1 BUGS |
| 259 | |
| 260 | If you find a bug, please send the SGF output file to gnugo@gnu.org |
| 261 | together with a description of the bug. |
| 262 | |
| 263 | =cut |