Commit | Line | Data |
---|---|---|
7eeb782e AT |
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 |