home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / games / volume13 / gnuchess4 / part11 < prev    next >
Internet Message Format  |  1992-08-03  |  57KB
  1. Path: uunet!zephyr.ens.tek.com!master!saab!billr
  2. From: billr@saab.CNA.TEK.COM (Bill Randle)
  3. Newsgroups: comp.sources.games
  4. Subject: v13i099:  gnuchess4 - GNU Chess 4.0, Part11/12
  5. Message-ID: <3066@master.CNA.TEK.COM>
  6. Date: 19 Jun 92 15:55:30 GMT
  7. Sender: news@master.CNA.TEK.COM
  8. Lines: 1999
  9. Approved: billr@saab.CNA.TEK.COM
  10.  
  11. Submitted-by: cracraft@rice-chex.ai.mit.edu (Stuart Cracraft)
  12. Posting-number: Volume 13, Issue 99
  13. Archive-name: gnuchess4/Part11
  14. Supersedes: gnuchess2: Volume 4, Issue 37-40
  15. Environment: 
  16.  
  17.  
  18.  
  19. #! /bin/sh
  20. # This is a shell archive.  Remove anything before this line, then unpack
  21. # it by saving it into a file and typing "sh file".  To overwrite existing
  22. # files, type "sh file -c".  You can also feed this as standard input via
  23. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  24. # will see the following message at the end:
  25. #        "End of archive 11 (of 12)."
  26. # Contents:  doc/ARTICLE.2 doc/MOVE-GEN misc/gnuchess.lang src/book.c
  27. #   src/genmoves.c src/main.c src/util.c
  28. # Wrapped by billr@saab on Fri Jun 19 08:36:02 1992
  29. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  30. if test -f 'doc/ARTICLE.2' -a "${1}" != "-c" ; then 
  31.   echo shar: Will not clobber existing file \"'doc/ARTICLE.2'\"
  32. else
  33. echo shar: Extracting \"'doc/ARTICLE.2'\" \(6615 characters\)
  34. sed "s/^X//" >'doc/ARTICLE.2' <<'END_OF_FILE'
  35. X
  36. X
  37. X                 GNU Chess: Experiences Learned
  38. X                      with Communal Sharing
  39. X                       by Stuart Cracraft
  40. X              (and contributors to the GNU Project)
  41. X
  42. X
  43. XLimited sharing has characterized the  computer  chess  community
  44. Xfor the past two decades. Occasional research articles give hints
  45. Xand suggestions for useful features, but rarely reveal  the  real
  46. Xdetails  of  the  critically  important  advances.  We  will here
  47. Xdescribe an effort underway (titled "GNU Chess") to create a more
  48. Xopen and friendly environment of sharing.
  49. X
  50. XGNU Chess is part of Project GNU, a large-scale effort  in  which
  51. Xthe philosophical goals are far-reaching. We will not go into any
  52. Xgreat depth about these goals as they relate to the  larger  pro-
  53. Xject, because these are described elsewhere [1]. However, we will
  54. Xmention the basic issues and the changes we hope to encourage.
  55. X
  56. XThe start of the GNU Chess project was a natural  result  of  the
  57. Xexperiences  gleaned in writing a chess program. While the author
  58. Xwas at a progressive academic location [2], he was able  to  con-
  59. Xceive the idea of a communal chess program only after much heart-
  60. Xache.  During the period of writing the initial  version  (which
  61. Xhas  since  undergone  many improvements and whole revisions), it
  62. Xbecame clear that the best features and most  useful  hints,  the
  63. Xvery best of the heuristics, were hidden and difficult to find in
  64. Xthe literature.
  65. X
  66. XSprinkled across many books, research papers, magazine  articles,
  67. Xaccumulated in the community, during the past 25 years, there was
  68. Xliterally a void of true,  empirical  programs.  Locating  usable
  69. Xprograms was difficult. Many programs were the result of academic
  70. Xwork in "ivory towers", and hence were inaccessible to the common
  71. Xman. Other programs were sequestered in research think-tanks. Na-
  72. Xturally, developers  of  commercial  programs  carefully  guarded
  73. Xtheir  source  in order to protect their investment. On the other
  74. Xhand, a few chess program source listings had actually been  pub-
  75. Xlished, but these were not really very strong, often written in a
  76. Xnon-general language, and frequently more pedantic  than  practi-
  77. Xcal.
  78. X
  79. XThe idea of a  reasonably  strong  communal  program  solidified.
  80. XWhen  we  refer  to  a communal program, we do not regard this as
  81. Xpublic-domain software. Rather, we refer to a  program  which  is
  82. Xunder  the shared authority of a number of individuals, the prin-
  83. Xcipal contributors.  These individuals have experienced and real-
  84. Xized  the  positive  results of a sharing community and the rapid
  85. Ximprovements that come through contributing in such a  community.
  86. XFurther, these individuals devote time and energy to coordinating
  87. Xthe contributions of other individuals.  While  they  exercise  a
  88. Xcertain editorial right, this is usually not exercised arbitrari-
  89. Xly; instead, a discussion is often undertaken.
  90. X
  91. XEventually, a working C program that played chess was  available.
  92. XThe  coordinating  institution  for Project GNU, accepted our
  93. Xsuggestion of inclusion of a chess program in the  GNU  distribu-
  94. Xtion.  Initial  distribution of GNU Chess commenced in October of
  95. X1986. Interest in the project increased rapidly.
  96. X
  97. XContributions came in from many places and people. Interfaces  to
  98. XX-windows  and SUN-windows were donated, thus allowing very fancy
  99. Xchess fonts on bit-mapped screens. Also, contributions  involving
  100. Xlarge  portions  of  opening books such as MCO and collections of
  101. Xmaster games  were  added  to  the  distribution.   Additionally,
  102. Xtree-search modifications and heuristics were provided, and occa-
  103. Xsionally even entire rewrites.
  104. X
  105. XThe program advanced in strength by several USCF class  intervals
  106. Xduring  a  period  of  less than one year. During this time, many
  107. Xunusual features and enhancements were added to the program, usu-
  108. Xally under the coordination of two or more people, with one work-
  109. Xing in a distant-advisory capacity to the other. Frequently, gra-
  110. Xduate  students  would give up significant time from their thesis
  111. Xwork to devote energy to contributing. Their  corporate  counter-
  112. Xparts would often give up project time to make their donation.
  113. X
  114. XContributors would often enter the project in a very forceful way
  115. Xand  then  having made their contribution, learn the viability of
  116. Xcommunal sharing once others had stepped in  and  contributed  to
  117. Xthem, thus providing considerable reinforcement. Frequently, con-
  118. Xtributors would then go into "hibernation" for a long  period  of
  119. Xtime,  but  most  of  them remained open to contributing and were
  120. Xhelpful when asked to reprogram their particular contribution  in
  121. Xa more recent version.
  122. X
  123. XGNU Chess has made great strides in relatively little  time.   It
  124. Xhas  run  on  many  different hardware architectures and has been
  125. Xcompiled by a number of C compilers. A sampling of  the  com-
  126. Xputers  on  which  the  program  has  run is: National 32032, Vax
  127. X11/750, 8550, 8600, 8650, Motorola  68020,  CCI  5/32,  CCI  6/32
  128. X(tahoe), Cray XMP, SUN Sparc-1.
  129. X
  130. XIt is our belief that GNU Chess will stimulate graduate  research
  131. Xin computer chess theory and practice.  When students are able to
  132. Xeasily obtain a state-of-the-art program in  order  to  test  out
  133. Xtheir  ideas, they will no longer need to reinvent the wheel. The
  134. Xstudents will be able to investigate their  research  areas  much
  135. Xmore thoroughly, because they will spend more time on the specif-
  136. Xic research areas they are concerned about.  Basically, GNU Chess
  137. X"frees up" time in order to get on to more fundamental issues.
  138. X
  139. XWe also feel that as other researchers  gain  trust  in  the  GNU
  140. XChess  project, they will be more likely to release their results
  141. Xdirectly and rapidly, through journal articles,  or  directly  to
  142. Xthe  GNU  project,  and  in fact become contributors and join the
  143. Xpresent list. At the very  least,  a  communal,  ever-growing
  144. Xprogram will encourage the few "closeted" researchers to be some-
  145. Xwhat more open in their approach to disseminating advances.
  146. X
  147. XIn whatever form it takes, the  progress  toward  elaboration  of
  148. Xmachine  chess  is  ongoing,  and  we hope that GNU chess will be
  149. Xhelpful to the community. Copies of GNU Chess source and  "book",
  150. Xas  well  as  additional experimental code are available from the
  151. XFree Software Foundation [3] or the author [6].
  152. X
  153. X
  154. X[1] The GNU Manifesto, Richard Stallman, Free Software Foundation, Inc.
  155. X
  156. X[2] University of Southern California, Information Sciences Institute.
  157. X
  158. X[3] Free Software Foundation, Inc. 675 Massachusetts Ave.,
  159. X    Cambridge MA 02139.
  160. X
  161. X[4] Stuart Cracraft, P.O. Box 2841, Laguna Hills, California.
  162. X    92654-2841., cracraft@wheaties.ai.mit.edu.
  163. END_OF_FILE
  164. if test 6615 -ne `wc -c <'doc/ARTICLE.2'`; then
  165.     echo shar: \"'doc/ARTICLE.2'\" unpacked with wrong size!
  166. fi
  167. # end of 'doc/ARTICLE.2'
  168. fi
  169. if test -f 'doc/MOVE-GEN' -a "${1}" != "-c" ; then 
  170.   echo shar: Will not clobber existing file \"'doc/MOVE-GEN'\"
  171. else
  172. echo shar: Extracting \"'doc/MOVE-GEN'\" \(3326 characters\)
  173. sed "s/^X//" >'doc/MOVE-GEN' <<'END_OF_FILE'
  174. XThis file contains a description of GNU's new move generation algoritm.
  175. X   Copyright (C) 1989 Free Software Foundation, Inc.
  176. X
  177. XThis file is part of CHESS.
  178. X
  179. XCHESS is distributed in the hope that it will be useful,
  180. Xbut WITHOUT ANY WARRANTY.  No author or distributor
  181. Xaccepts responsibility to anyone for the consequences of using it
  182. Xor for whether it serves any particular purpose or works at all,
  183. Xunless he says so in writing.  Refer to the CHESS General Public
  184. XLicense for full details.
  185. X
  186. XEveryone is granted permission to copy, modify and redistribute
  187. XCHESS, but only under the conditions described in the
  188. XCHESS General Public License.   A copy of this license is
  189. Xsupposed to have been given to you along with CHESS so you
  190. Xcan know your rights and responsibilities.  It should be in a
  191. Xfile named COPYING.  Among other things, the copyright notice
  192. Xand this notice must be preserved on all copies.
  193. X
  194. XNew move Generation algoritm:
  195. X
  196. XRevision: 1989-09-06
  197. X
  198. XAuthor: Hans Eric Sandstroem.
  199. X
  200. XThis algortim is the result of an attempt to make an hardware move
  201. Xgenerator, but since I newer had the time and resources to build
  202. Xthe hardware I wrote a software version and incorporated that one
  203. Xinto gnuchess. This was the best way I could think of sharing this
  204. Xalgorithm with the computer chess community.
  205. X
  206. XIf there is anybody out there with the time and rescources to build
  207. Xa hardware move generator I will be glad to assist.
  208. X
  209. XThe general idea behind this algoritm is to pre calculate
  210. Xa lot of data. The data that is pre calculated is every possible move
  211. Xfor every piece from every square disregarding any other pieces on the
  212. Xboard. This pre calculated data is stored in an array that looks like
  213. Xthis:
  214. X
  215. Xstruct sqdata {
  216. X  short nextpos;
  217. X  short nextdir;
  218. X};
  219. Xstruct sqdata posdata[8][64][64];
  220. X/* posdata[piecetype][fromsquare][destinationsquare] */
  221. Xexample:
  222. X    the first move for a queen at e8 is stored at;
  223. X    posdata[queen][e8][e8].nextpos
  224. X    suppose this is e7 and e7 is occupied then the next move
  225. X    will be found in;
  226. X    posdata[queen][e8][e7].nextdir
  227. X
  228. XTo handle the differeces between white and black pawns (they move in
  229. Xopposite directions) an array ptype has been introduced:
  230. X
  231. Xstatic const short ptype[2][8] = {
  232. X  no_piece,pawn,knight,bishop,rook,queen,king,no_piece,
  233. X  no_piece,bpawn,knight,bishop,rook,queen,king,no_piece};
  234. X           ^^^^^
  235. XAnd it is used like this:
  236. X   piecetype = ptype[side][piece]
  237. XWhen generating moves for pieces that are not black pawns, piece
  238. Xcan be used directly in posdata. As in the example above.
  239. X
  240. XThus the only thing one has to do when generating the moves
  241. Xis to check for collisions with other pieces. 
  242. Xthe move generation to do this looks like this: (for non pawns)
  243. X    p = posdata[piece][sq];
  244. X    u = p[sq].nextpos;
  245. X    do {
  246. X      if (color[u] == neutral) {
  247. X    LinkMove(ply,sq,u,xside);
  248. X    u = p[u].nextpos;
  249. X      }
  250. X      else {
  251. X    if (color[u] == xside) LinkMove(ply,sq,u,xside);
  252. X    u = p[u].nextdir;
  253. X      }
  254. X    } while (u != sq);
  255. X
  256. X - I`nt this just beautiful!
  257. X
  258. XThe array posdata is initialized in the routine Initialize_moves.
  259. XThis routine is called just once and it works so no time has been spent
  260. Xon the structure of this code. GenMoves and CaptureList generates the
  261. Xmoves but the routines ataks, BRscan, Sqatakd, KingScan and trapped
  262. Xalso relies on the move generation algoritm so they have also been
  263. Xrewritten.
  264. X
  265. X
  266. X
  267. END_OF_FILE
  268. if test 3326 -ne `wc -c <'doc/MOVE-GEN'`; then
  269.     echo shar: \"'doc/MOVE-GEN'\" unpacked with wrong size!
  270. fi
  271. # end of 'doc/MOVE-GEN'
  272. fi
  273. if test -f 'misc/gnuchess.lang' -a "${1}" != "-c" ; then 
  274.   echo shar: Will not clobber existing file \"'misc/gnuchess.lang'\"
  275. else
  276. echo shar: Extracting \"'misc/gnuchess.lang'\" \(6777 characters\)
  277. sed "s/^X//" >'misc/gnuchess.lang' <<'END_OF_FILE'
  278. X001:eng:{ pnbrqk}
  279. X002:eng:{ PNBRQK}
  280. X003:eng:{abcdefgh}
  281. X004:eng:{12345678}
  282. X005:eng:{o-o}
  283. X006:eng:{o-o-o}
  284. X007:eng:{0-0}
  285. X008:eng:{0-0-0}
  286. X009:eng:{wWbB}
  287. X010:eng:{       score  depth   nodes  time         }
  288. X011:eng:{       score  depth   nodes  time\n}
  289. X012:eng:{     }
  290. X013:eng:{   }
  291. X014:eng:{  %s\n}
  292. X015:eng:{  a    b    c    d    e    f    g    h}
  293. X016:eng:{  h    g    f    e    d    c    b    a}
  294. X017:eng:{ -}
  295. X018:eng:{ 1.   60 moves in   5 minutes}
  296. X019:eng:{ 2.   60 moves in  15 minutes}
  297. X020:eng:{ 3.   60 moves in  30 minutes}
  298. X021:eng:{ 4.   40 moves in  30 minutes}
  299. X022:eng:{ 5.   40 moves in  60 minutes}
  300. X023:eng:{ 6.   40 moves in 120 minutes}
  301. X024:eng:{ 7.   40 moves in 240 minutes}
  302. X025:eng:{ 8.    1 move  in  15 minutes}
  303. X026:eng:{ 9.    1 move  in  60 minutes}
  304. X027:eng:{10.    1 move  in 600 minutes}
  305. X028:eng:{#   Clear board\n}
  306. X029:eng:{.   Exit to main\n}
  307. X030:eng:{/usr/games/lib/gnuchess.book}
  308. X031:eng:{Abort? }
  309. X032:eng:{Ambiguous Move!}
  310. X033:eng:{Awindow}
  311. X034:eng:{BAwindow= }
  312. X035:eng:{BBwindow= }
  313. X036:eng:{Beep:     %-12s Transposition file: %s\n}
  314. X037:eng:{Black %s White %s %d\n}
  315. X038:eng:{Bwindow: }
  316. X039:eng:{Bwindow}
  317. X040:eng:{CHESS command summary\n}
  318. X041:eng:{CHESS}
  319. X042:eng:{Castled White %s Black %s\n}
  320. X043:eng:{Chess\n}
  321. X044:eng:{Computer mates!}
  322. X045:eng:{Computer will soon mate!}
  323. X046:eng:{Computer: %-12s Opponent:            %s\n}
  324. X047:eng:{Computer: %s}
  325. X048:eng:{Could not open file}
  326. X049:eng:{Counting transposition file entries, wait!\n}
  327. X050:eng:{Create failed for %s\n}
  328. X051:eng:{Depth:    %-12d Response time:       %d sec\n}
  329. X052:eng:{Depth: %d}
  330. X053:eng:{Depth= %d%c }
  331. X054:eng:{Draw %s\n}
  332. X055:eng:{DrawPiece:  color[sq] err}
  333. X056:eng:{Drawn game! %s}
  334. X057:eng:{Drawn game!\n}
  335. X058:eng:{Drawn game!}
  336. X059:eng:{Easy mode: %s}
  337. X060:eng:{Editing: %s}
  338. X061:eng:{Enter #moves #minutes: }
  339. X062:eng:{Enter Level: }
  340. X063:eng:{Enter file name: }
  341. X064:eng:{Enter piece & location: }
  342. X065:eng:{Enter piece: }
  343. X066:eng:{Filling transposition file, wait!\n}
  344. X067:eng:{GNU Chess display (MS-DOS, Mar 90)}
  345. X068:eng:{GNU Chess display (Nov 89)}
  346. X069:eng:{GNU Chess}
  347. X070:eng:{Game saved}
  348. X071:eng:{Hin/Hout/Tcol/Coll/Fin/Fout = %ld/%ld/%ld/%ld/%ld/%ld\n}
  349. X072:eng:{Hint: %s\n}
  350. X073:eng:{Hit <RET> to return: }
  351. X074:eng:{Human}
  352. X075:eng:{Illegal move (no matching move)%s\n}
  353. X076:eng:{Illegal move (no matching move)}
  354. X077:eng:{Illegal move..(in check)}
  355. X078:eng:{Illegal move\n}
  356. X079:eng:{Level: %ld}
  357. X080:eng:{Max Moves}
  358. X081:eng:{Max Tree= %5d}
  359. X082:eng:{MoveLimit= }
  360. X083:eng:{My move is: %s\n}
  361. X084:eng:{My move is: %s}
  362. X085:eng:{Testing Eval Speed}
  363. X086:eng:{Nf3       move knight to f3       beep      turn %s\n}
  364. X087:eng:{No moves}
  365. X088:eng:{No pieces}
  366. X089:eng:{Nodes %ld Tree %d Eval %ld Rate %ld RS hi %ld lo %ld \n}
  367. X090:eng:{Nodes= %8ld, Nodes/Sec= %5ld}
  368. X091:eng:{Nodes= %ld Nodes/sec= %ld\n}
  369. X092:eng:{OFF}
  370. X093:eng:{ON}
  371. X094:eng:{Operator time(hundredths)= }
  372. X095:eng:{Opponent mates!}
  373. X096:eng:{Opponent will soon mate!}
  374. X097:eng:{Opponent: %s}
  375. X098:eng:{Playing without hashfile}
  376. X099:eng:{Random:   %-12s Easy mode:           %s\n}
  377. X100:eng:{Random: %s}
  378. X101:eng:{Repetition}
  379. X102:eng:{Gnuchess version %s patchlevel %s\n}
  380. X103:eng:{S=%d m%d p%d ps%d ss%d m%d p%d ps%d ss%d}
  381. X104:eng:{Score= %d}
  382. X105:eng:{Score}
  383. X106:eng:{Setup successful\n}
  384. X107:eng:{Testing CaptureList Speed}
  385. X108:eng:{Testing MoveList Speed}
  386. X109:eng:{The file contains %d entries out of max %d\n}
  387. X110:eng:{Time Control %s %d moves %d sec %d opr %d depth\n}
  388. X111:eng:{TimeControl %d Operator Time %d\n}
  389. X112:eng:{Transposition table: %s}
  390. X113:eng:{Usage: Gnuchess [-a] [-t] [-c size] [-s savefile][-l listfile] [-x xwndw]\n}
  391. X114:eng:{WAwindow= }
  392. X115:eng:{WBwindow= }
  393. X116:eng:{White %d:%02d  Black %d:%02d\n}
  394. X117:eng:{White Clock %ld Moves %ld\nBlack Clock %d Moves %d\n\n}
  395. X118:eng:{White}
  396. X119:eng:{Black}
  397. X120:eng:{Wwindow: }
  398. X121:eng:{Your move is? }
  399. X122:eng:{\n                          }
  400. X123:eng:{\nMove# %d    Target= %ld    Clock: %ld\n}
  401. X124:eng:{\nYour move is? }
  402. X125:eng:{\n\n}
  403. X126:eng:{\nmove  score depth  nodes  time flags capture color\n}
  404. X127:eng:{\n}
  405. X128:eng:{a7a8q     promote pawn to queen   material  turn %s\n}
  406. X129:eng:{alg}
  407. X130:eng:{bd        redraw board            reverse   board display\n}
  408. X131:eng:{bd}
  409. X132:eng:{beep}
  410. X133:eng:{black}
  411. X134:eng:{book}
  412. X135:eng:{both}
  413. X136:eng:{c   Change sides\n}
  414. X137:eng:{chess.000}
  415. X138:eng:{chess.lst.%d}
  416. X139:eng:{computer mates!\n}
  417. X140:eng:{computer will soon mate!\n}
  418. X141:eng:{computer}
  419. X142:eng:{contempt= }
  420. X143:eng:{contempt}
  421. X144:eng:{coords    show coords             rv        reverse video\n}
  422. X145:eng:{coords}
  423. X146:eng:{debuglevel= }
  424. X147:eng:{debuglevel}
  425. X148:eng:{debug}
  426. X149:eng:{depth     set search depth        clock     set time control\n}
  427. X150:eng:{depth= }
  428. X151:eng:{depth}
  429. X152:eng:{easy}
  430. X153:eng:{edit      edit board              force     enter game moves\n}
  431. X154:eng:{edit}
  432. X155:eng:{enter piece & location: \n}
  433. X156:eng:{first}
  434. X157:eng:{force}
  435. X158:eng:{g1f3      move from g1 to f3      quit      Exit Chess\n}
  436. X159:eng:{game file= }
  437. X160:eng:{get}
  438. X161:eng:{gnuchess 4p%s game\n}
  439. X162:eng:{go}
  440. X163:eng:{hashdepth= }
  441. X164:eng:{hashdepth}
  442. X165:eng:{hash}
  443. X166:eng:{help}
  444. X167:eng:{hint      suggest a move         post      turn %s principle variation\n}
  445. X168:eng:{hint}
  446. X169:eng:{level}
  447. X170:eng:{list      game to chess.lst       book      turn %s used %d of %d\n}
  448. X171:eng:{list}
  449. X172:eng:{new}
  450. X173:eng:{o-o       castle king side        easy      turn %s\n}
  451. X174:eng:{o-o-o     castle queen side       hash      turn %s\n}
  452. X175:eng:{opponent mates!\n}
  453. X176:eng:{opponent will soon mate!\n}
  454. X177:eng:{post      principle variation     hint      suggest a move\n}
  455. X178:eng:{post}
  456. X179:eng:{p}
  457. X180:eng:{quit}
  458. X181:eng:{random    randomize play          new       start new game\n}
  459. X182:eng:{random}
  460. X183:eng:{rcptr}
  461. X184:eng:{remove}
  462. X185:eng:{reverse}
  463. X186:eng:{rv}
  464. X187:eng:{r}
  465. X188:eng:{save      game to file            get       game from file\n}
  466. X189:eng:{save}
  467. X190:eng:{setup}
  468. X191:eng:{set}
  469. X192:eng:{shade     toggle shade black      stars     toggle stars\n}
  470. X193:eng:{stars}
  471. X194:eng:{switch    sides with computer     both      computer match\n}
  472. X195:eng:{switch}
  473. X196:eng:{test}
  474. X197:eng:{time}
  475. X198:eng:{try }
  476. X199:eng:{ttable collision detected}
  477. X200:eng:{undo      undo last ply           remove    take back a move\n}
  478. X201:eng:{undo}
  479. X202:eng:{white     computer plays white    black     computer plays black\n}
  480. X203:eng:{white}
  481. X204:eng:{w}
  482. X205:eng:{xboard.position.read}
  483. X206:eng:{xboard}
  484. X207:eng:{xget}
  485. X208:eng:{xwndw= }
  486. X209:eng:{xwndw}
  487. X210:eng:{yes}
  488. X211:eng:{Illegal move in book %d %s %s}
  489. X212:eng:{Warning can't find book.}
  490. X213:eng:{Book used %d of %d entries.}
  491. X214:eng:{true}
  492. X215:eng:{false}
  493. X216:eng:{exit}
  494. X217:eng:{clock}
  495. X218:eng:{Computer}
  496. X219:eng:{Open failure for file: %s}
  497. X220:eng:{Time Control Error}
  498. X221:eng:{material}
  499. X222:eng:{time %d %d}
  500. X223:eng:{I have no idea}
  501. X224:eng:{Not Enough Material}
  502. END_OF_FILE
  503. if test 6777 -ne `wc -c <'misc/gnuchess.lang'`; then
  504.     echo shar: \"'misc/gnuchess.lang'\" unpacked with wrong size!
  505. fi
  506. # end of 'misc/gnuchess.lang'
  507. fi
  508. if test -f 'src/book.c' -a "${1}" != "-c" ; then 
  509.   echo shar: Will not clobber existing file \"'src/book.c'\"
  510. else
  511. echo shar: Extracting \"'src/book.c'\" \(8155 characters\)
  512. sed "s/^X//" >'src/book.c' <<'END_OF_FILE'
  513. X/*
  514. X * book.c - C source for GNU CHESS
  515. X *
  516. X * Copyright (c) 1988,1989,1990 John Stanback
  517. X * Copyright (c) 1992 Free Software Foundation
  518. X *
  519. X * This file is part of GNU CHESS.
  520. X *
  521. X * GNU Chess is free software; you can redistribute it and/or modify
  522. X * it under the terms of the GNU General Public License as published by
  523. X * the Free Software Foundation; either version 2, or (at your option)
  524. X * any later version.
  525. X *
  526. X * GNU Chess is distributed in the hope that it will be useful,
  527. X * but WITHOUT ANY WARRANTY; without even the implied warranty of
  528. X * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  529. X * GNU General Public License for more details.
  530. X *
  531. X * You should have received a copy of the GNU General Public License
  532. X * along with GNU Chess; see the file COPYING.  If not, write to
  533. X * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  534. X */
  535. X
  536. X#include "gnuchess.h"
  537. Xextern char mvstr[4][6];
  538. Xshort bookcount = 0;
  539. Xstatic struct bookentry
  540. X{
  541. X  unsigned long bookkey;
  542. X  unsigned long bookbd;
  543. X  unsigned short bmove;
  544. X  unsigned short hint;
  545. X  unsigned char count;
  546. X  unsigned char flags;
  547. X} OpenBook[BOOKSIZE];
  548. Xstatic struct bookentry *BookTable[BKTBLSIZE];
  549. Xvoid
  550. XGetOpenings (void)
  551. X
  552. X/*
  553. X * Read in the Opening Book file and parse the algebraic notation for a move
  554. X * into an unsigned integer format indicating the from and to square. Create
  555. X * a linked list of opening lines of play, with entry->next pointing to the
  556. X * next line and entry->move pointing to a chunk of memory containing the
  557. X * moves. More Opening lines of up to 100 half moves may be added to
  558. X * gnuchess.book.
  559. X */
  560. X#ifndef BOOK
  561. X#define BOOK "/usr/games/lib/gnuchess.book"
  562. X#endif /* BOOK */
  563. X{
  564. X  FILE *fd;
  565. X  register struct bookentry *OB, *OC;
  566. X  register short int i, f, t;
  567. X  char opening[80];
  568. X  char msg[80];
  569. X  short int xside, doit, c, side;
  570. X  short int rf, rt;
  571. X  unsigned short mv;
  572. X
  573. X
  574. X  for (OB = OpenBook; OB < &OpenBook[BOOKSIZE]; OB++)
  575. X    OB->count = 0;
  576. X  for (i = 0; i < BKTBLSIZE; i++)
  577. X    {
  578. X      BookTable[i] = &OpenBook[BOOKSIZE / BKTBLSIZE * i];
  579. X    }
  580. X  if ((fd = fopen (BOOK, "r")) == NULL)
  581. X    fd = fopen ("gnuchess.book", "r");
  582. X  if (fd != NULL)
  583. X    {
  584. X      OC = NULL;
  585. X      /* setvbuf(fd,buffr,_IOFBF,2048); */
  586. X      side = white;
  587. X      xside = black;
  588. X      hashbd = hashkey = 0;
  589. X      for (i = 0; i < 64; i++)
  590. X    {
  591. X      board[i] = Stboard[i];
  592. X      color[i] = Stcolor[i];
  593. X    }
  594. X      i = 0;
  595. X
  596. X      while ((c = parse (fd, &mv, side, opening)) >= 0)
  597. X    if (c == 1)
  598. X      {
  599. X
  600. X        /*
  601. X         * if not first move of an opening and first time we have
  602. X         * seen it save next move as hint
  603. X         */
  604. X        if (i && OB->count == 1)
  605. X          OB->hint = mv & 0x3f3f;
  606. X        OC = OB;        /* save for end marking */
  607. X        doit = true;
  608. X
  609. X        /*
  610. X         * see if this position and move already exist from some
  611. X         * other opening
  612. X         */
  613. X        /* is this ethical, to offer the bad move as a hint????? */
  614. X        for (OB = BookTable[hashkey & BOOKMASK]; OB->count; OB++)
  615. X          {
  616. X        if (OB->bookkey == hashkey
  617. X            && OB->bookbd == hashbd
  618. X            && (OB->flags & SIDEMASK) == side
  619. X            && OB->bmove == mv)
  620. X          {
  621. X
  622. X            /*
  623. X             * yes so just bump count - count is used to choose
  624. X             * opening move in proportion to its presence in the
  625. X             * book
  626. X             */
  627. X            doit = false;
  628. X            OB->count++;
  629. X            break;
  630. X          }
  631. X        /* Book is hashed into BKTBLSIZE chunks based on hashkey */
  632. X        if (OB == &OpenBook[BOOKSIZE - 1])
  633. X          OB = OpenBook;
  634. X          }
  635. X        /* doesn`t exist so add it to the book */
  636. X        if (doit)
  637. X          {
  638. X        bookcount++;
  639. X        OB->bookkey = hashkey;
  640. X        OB->bookbd = hashbd;
  641. X        OB->bmove = mv;
  642. X        OB->hint = 0;
  643. X        OB->count = 1;
  644. X        OB->flags = side;
  645. X          }
  646. X        /* now update the board and hash values */
  647. X        /* should really check the moves as we do this, but??? */
  648. X        f = mv >> 8 & 0x3F;
  649. X        t = mv & 0x3F;
  650. X        if (board[t] != no_piece)
  651. X          {
  652. X        if (color[t] != xside)
  653. X          {
  654. X            algbr (f, t, false);
  655. X            sprintf (msg, CP[211], i + 1, mvstr, opening);
  656. X            ShowMessage (msg);
  657. X          }
  658. X        UpdateHashbd (xside, board[t], -1, t);
  659. X          }
  660. X        if (board[f] == no_piece || color[f] != side)
  661. X          {
  662. X        algbr (f, t, false);
  663. X        sprintf (msg, CP[211], i + 1, mvstr, opening);
  664. X        ShowMessage (msg);
  665. X          }
  666. X        UpdateHashbd (side, board[f], f, t);
  667. X        board[t] = board[f];
  668. X        color[t] = color[f];
  669. X        color[f] = neutral;
  670. X        board[f] = no_piece;
  671. X        if ((board[t] == king) && ((mv == BLACKCASTLE) || (mv == WHITECASTLE) || (mv == LONGBLACKCASTLE) || (mv == LONGWHITECASTLE)))
  672. X          {
  673. X
  674. X        if (t > f)
  675. X          {
  676. X            rf = f + 3;
  677. X            rt = t - 1;
  678. X          }
  679. X        else
  680. X          {
  681. X            rf = f - 4;
  682. X            rt = t + 1;
  683. X          }
  684. X        board[rt] = rook;
  685. X        color[rt] = side;
  686. X        board[rf] = no_piece;
  687. X        color[rf] = neutral;
  688. X        UpdateHashbd (side, rook, rf, rt);
  689. X          }
  690. X        i++;
  691. X        xside = side;
  692. X        side = side ^ 1;
  693. X      }
  694. X    else if (c == 0 && i > 0)
  695. X      {
  696. X        /* Mark last move as end of an opening */
  697. X        /* might want to terminate? */
  698. X        OB->flags |= BOOKEND;
  699. X        if (i > 1)
  700. X          OC->flags |= BOOKEND;
  701. X        /* reset for next opening */
  702. X        side = white;
  703. X        hashbd = hashkey = 0;
  704. X        for (i = 0; i < 64; i++)
  705. X          {
  706. X        board[i] = Stboard[i];
  707. X        color[i] = Stcolor[i];
  708. X          }
  709. X        i = 0;
  710. X
  711. X      }
  712. X      fclose (fd);
  713. X#if !defined CHESSTOOL && !defined XBOARD
  714. X      sprintf (msg, CP[213], bookcount, BOOKSIZE);
  715. X      ShowMessage (msg);
  716. X#endif
  717. X      /* set every thing back to start game */
  718. X      Book = BOOKFAIL;
  719. X      for (i = 0; i < 64; i++)
  720. X    {
  721. X      board[i] = Stboard[i];
  722. X      color[i] = Stcolor[i];
  723. X    }
  724. X    }
  725. X  else
  726. X    {
  727. X#if !defined CHESSTOOL && !defined XBOARD
  728. X      ShowMessage (CP[212]);
  729. X#endif
  730. X      Book = 0;
  731. X    }
  732. X}
  733. X
  734. X
  735. Xint
  736. XOpeningBook (unsigned short *hint, short int side)
  737. X
  738. X/*
  739. X * Go thru each of the opening lines of play and check for a match with the
  740. X * current game listing. If a match occurs, generate a random number. If this
  741. X * number is the largest generated so far then the next move in this line
  742. X * becomes the current "candidate". After all lines are checked, the
  743. X * candidate move is put at the top of the Tree[] array and will be played by
  744. X * the program. Note that the program does not handle book transpositions.
  745. X */
  746. X
  747. X{
  748. X  short pnt;
  749. X  unsigned short m;
  750. X  unsigned r, cnt, tcnt, ccnt;
  751. X  register struct bookentry *OB, *OC;
  752. X  int possibles = TrPnt[2] - TrPnt[2];
  753. X
  754. X  srand ((unsigned int) time ((long *) 0));
  755. X  m = 0;
  756. X  cnt = 0;
  757. X  tcnt = 0;
  758. X  ccnt = 0;
  759. X  OC = NULL;
  760. X
  761. X
  762. X  /*
  763. X   * find all the moves for this position  - count them and get their total
  764. X   * count
  765. X   */
  766. X  for (OB = BookTable[hashkey & BOOKMASK]; OB->count; OB++)
  767. X    {
  768. X      if (OB->bookkey == hashkey
  769. X      && OB->bookbd == hashbd
  770. X      && ((OB->flags) & SIDEMASK) == side)
  771. X    {
  772. X      if (OB->bmove & BADMOVE)
  773. X        {
  774. X          m = OB->bmove ^ BADMOVE;
  775. X          /* is the move is in the MoveList */
  776. X          for (pnt = TrPnt[1]; pnt < TrPnt[2]; pnt++)
  777. X        {
  778. X          if (((Tree[pnt].f << 8) | Tree[pnt].t) == m)
  779. X            {
  780. X              if (--possibles)
  781. X            {
  782. X              Tree[pnt].score = DONTUSE;
  783. X              break;
  784. X            }
  785. X            }
  786. X        }
  787. X
  788. X        }
  789. X      else
  790. X        {
  791. X          OC = OB;
  792. X          cnt++;
  793. X          tcnt += OB->count;
  794. X        }
  795. X    }
  796. X    }
  797. X  /* if only one just do it */
  798. X  if (cnt == 1)
  799. X    {
  800. X      m = OC->bmove;
  801. X    }
  802. X  else
  803. X    /* more than one must choose one at random */
  804. X  if (cnt > 1)
  805. X    {
  806. X      /* pick a number */
  807. X      r = urand () % 1000;
  808. X
  809. X      for (OC = BookTable[hashkey & BOOKMASK]; OC->count; OC++)
  810. X    {
  811. X      if (OC->bookkey == hashkey
  812. X          && OC->bookbd == hashbd
  813. X          && ((OC->flags) & SIDEMASK) == side
  814. X          && !(OC->bmove & BADMOVE))
  815. X        {
  816. X          ccnt += OC->count;
  817. X          if (((ccnt * BOOKRAND) / tcnt) >= r)
  818. X        {
  819. X          m = OC->bmove;
  820. X          break;
  821. X        }
  822. X        }
  823. X    }
  824. X    }
  825. X  else
  826. X    {
  827. X      /* none decrement count of no finds */
  828. X      Book--;
  829. X      return false;
  830. X    }
  831. X  /* make sure the move is in the MoveList */
  832. X  for (pnt = TrPnt[1]; pnt < TrPnt[2]; pnt++)
  833. X    {
  834. X      if (((Tree[pnt].f << 8) | Tree[pnt].t) == m)
  835. X    {
  836. X      Tree[pnt].score = 0;
  837. X      break;
  838. X    }
  839. X    }
  840. X  /* Make sure its the best */
  841. X
  842. X  pick (TrPnt[1], TrPnt[2] - 1);
  843. X  if (Tree[TrPnt[1]].score)
  844. X    {
  845. X      /* no! */
  846. X      Book--;
  847. X      return false;
  848. X    }
  849. X  /* ok pick up the hint and go */
  850. X  *hint = OC->hint;
  851. X  Book = ((OC->flags & BOOKEND) && ((urand () % 1000) > BOOKENDPCT)) ? 0 : BOOKFAIL;
  852. X  return true;
  853. X}
  854. END_OF_FILE
  855. if test 8155 -ne `wc -c <'src/book.c'`; then
  856.     echo shar: \"'src/book.c'\" unpacked with wrong size!
  857. fi
  858. # end of 'src/book.c'
  859. fi
  860. if test -f 'src/genmoves.c' -a "${1}" != "-c" ; then 
  861.   echo shar: Will not clobber existing file \"'src/genmoves.c'\"
  862. else
  863. echo shar: Extracting \"'src/genmoves.c'\" \(7906 characters\)
  864. sed "s/^X//" >'src/genmoves.c' <<'END_OF_FILE'
  865. X/*
  866. X * genmoves.c - C source for GNU CHESS
  867. X *
  868. X * Copyright (c) 1988,1989,1990 John Stanback
  869. X * Copyright (c) 1992 Free Software Foundation
  870. X *
  871. X * This file is part of GNU CHESS.
  872. X *
  873. X * GNU Chess is free software; you can redistribute it and/or modify
  874. X * it under the terms of the GNU General Public License as published by
  875. X * the Free Software Foundation; either version 2, or (at your option)
  876. X * any later version.
  877. X *
  878. X * GNU Chess is distributed in the hope that it will be useful,
  879. X * but WITHOUT ANY WARRANTY; without even the implied warranty of
  880. X * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  881. X * GNU General Public License for more details.
  882. X *
  883. X * You should have received a copy of the GNU General Public License
  884. X * along with GNU Chess; see the file COPYING.  If not, write to
  885. X * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  886. X */
  887. X#include "gnuchess.h"
  888. Xshort *TrP;
  889. X
  890. X#define Link(from,to,flag,s) \
  891. X{\
  892. X   node->f = from; node->t = to;\
  893. X     node->reply = 0;\
  894. X       node->flags = flag;\
  895. X     node->score = s;\
  896. X       ++node;\
  897. X         *TrP += 1;\
  898. X         }
  899. X
  900. Xinline void
  901. XLinkMove (short int ply, short int f,
  902. X      short int t,
  903. X      short int flag,
  904. X      short int xside)
  905. X
  906. X/*
  907. X * Add a move to the tree.  Assign a bonus to order the moves as follows: 1.
  908. X * Principle variation 2. Capture of last moved piece 3. Other captures
  909. X * (major pieces first) 4. Killer moves 5.
  910. X */
  911. X
  912. X{
  913. X  register short s;
  914. X#if !defined NOHISTORY
  915. X  register short z;
  916. X#endif
  917. X  register unsigned short mv;
  918. X  register struct leaf *node;
  919. X
  920. X  node = &Tree[*TrP];
  921. X  mv = (f << 8) | t;
  922. X#if defined NOHISTORY
  923. X  s = killt[mv | sidebit];
  924. X#else
  925. X  z = (f << 6) | t;
  926. X  if (xside == white)
  927. X    z |= 0x1000;
  928. X  s = history[z];
  929. X#endif
  930. X  if (color[t] != neutral)
  931. X    {
  932. X      /* TOsquare is the square the last piece moved moved to */
  933. X      s += value[board[t]] - board[f] + ((t == TOsquare) ? 500 : 0);
  934. X    }
  935. X  if (board[f] == pawn)
  936. X    if (row (t) == 0 || row (t) == 7)
  937. X      {
  938. X    flag |= promote;
  939. X    s += 800;
  940. X#if !defined OLDXBOARD  && !defined GNU3 && !defined CHESSTOOL
  941. X    Link (f, t, flag | queen, s - 20000);
  942. X    s -= 200;
  943. X    Link (f, t, flag | knight, s - 20000);
  944. X    s -= 50;
  945. X    Link (f, t, flag | rook, s - 20000);
  946. X    flag |= bishop;
  947. X    s -= 50;
  948. X#else
  949. X    flag |= queen;
  950. X#endif
  951. X      }
  952. X    else if (row (t) == 1 || row (t) == 6)
  953. X      {
  954. X    flag |= pwnthrt;
  955. X    s += 600;
  956. X      }
  957. X    else if ((row (t) == 2 || row (t) == 5) && (ply > MINDEPTH) && (ply < Sdepth+3))
  958. X      {
  959. X    if ((mtl[white] - pmtl[white] + mtl[black] - pmtl[black]) < PTVALUE)
  960. X      {
  961. X        flag |= pwnthrt;
  962. X        s += 400;
  963. X      }
  964. X      }
  965. X  Link (f, t, flag, s - 20000);
  966. X}
  967. X
  968. Xinline
  969. Xvoid
  970. XGenMoves (register short int ply, register short int sq, short int side, short int xside)
  971. X
  972. X/*
  973. X * Generate moves for a piece. The moves are taken from the precalulated
  974. X * array nextpos/nextdir. If the board is free, next move is choosen from
  975. X * nextpos else from nextdir.
  976. X */
  977. X
  978. X{
  979. X  register short u, piece;
  980. X  register unsigned char *ppos, *pdir;
  981. X
  982. X  TrP = &TrPnt[ply + 1];
  983. X  piece = board[sq];
  984. X  ppos = nextpos[ptype[side][piece]][sq];
  985. X  pdir = nextdir[ptype[side][piece]][sq];
  986. X  if (piece == pawn)
  987. X    {
  988. X      u = ppos[sq];        /* follow no captures thread */
  989. X      if (color[u] == neutral)
  990. X    {
  991. X      LinkMove (ply, sq, u, 0, xside);
  992. X      u = ppos[u];
  993. X      if (color[u] == neutral)
  994. X        LinkMove (ply, sq, u, 0, xside);
  995. X    }
  996. X      u = pdir[sq];        /* follow captures thread */
  997. X      if (color[u] == xside)
  998. X    LinkMove (ply, sq, u, capture, xside);
  999. X      u = pdir[u];
  1000. X      if (color[u] == xside)
  1001. X    LinkMove (ply, sq, u, capture, xside);
  1002. X    }
  1003. X  else
  1004. X    {
  1005. X      u = ppos[sq];
  1006. X      do
  1007. X    {
  1008. X      if (color[u] == neutral)
  1009. X        {
  1010. X          LinkMove (ply, sq, u, 0, xside);
  1011. X          u = ppos[u];
  1012. X        }
  1013. X      else
  1014. X        {
  1015. X          if (color[u] == xside)
  1016. X        LinkMove (ply, sq, u, capture, xside);
  1017. X          u = pdir[u];
  1018. X        }
  1019. X      } while (u != sq);
  1020. X    }
  1021. X}
  1022. X
  1023. Xvoid
  1024. XMoveList (short int side, register short int ply)
  1025. X
  1026. X/*
  1027. X * Fill the array Tree[] with all available moves for side to play. Array
  1028. X * TrPnt[ply] contains the index into Tree[] of the first move at a ply.
  1029. X */
  1030. X
  1031. X{
  1032. X  register short i, xside, f;
  1033. X
  1034. X  xside = side ^ 1;
  1035. X  TrP = &TrPnt[ply + 1];
  1036. X  *TrP = TrPnt[ply];
  1037. X  if (!PV)
  1038. X    Swag0 = killr0[ply];
  1039. X  Swag1 = killr1[ply];
  1040. X  Swag2 = killr2[ply];
  1041. X  Swag3 = killr3[ply];
  1042. X  if (ply > 2)
  1043. X    Swag4 = killr1[ply - 2];
  1044. X  sidebit = ((side == white) ? 0 : 0x80);
  1045. X  killt[SwagHt | sidebit] += 5000;
  1046. X  killt[Swag0 | sidebit] += 2000;
  1047. X  killt[Swag1 | sidebit] += 60;
  1048. X  killt[Swag2 | sidebit] += 50;
  1049. X  killt[Swag3 | sidebit] += 40;
  1050. X  killt[Swag4 | sidebit] += 30;
  1051. X  for (i = PieceCnt[side]; i >= 0; i--)
  1052. X    GenMoves (ply, PieceList[side][i], side, xside);
  1053. X  if (!castld[side])
  1054. X    {
  1055. X      f = PieceList[side][0];
  1056. X      if (castle (side, f, f + 2, 0))
  1057. X    {
  1058. X      LinkMove (ply, f, f + 2, cstlmask, xside);
  1059. X    }
  1060. X      if (castle (side, f, f - 2, 0))
  1061. X    {
  1062. X      LinkMove (ply, f, f - 2, cstlmask, xside);
  1063. X    }
  1064. X    }
  1065. X  if (epsquare > 0)
  1066. X    {
  1067. X      f = epmove1[epsquare];
  1068. X      if (color[f] == side && board[f] == pawn)
  1069. X    LinkMove (ply, f, epsquare, capture | epmask, xside);
  1070. X      f = epmove2[epsquare];
  1071. X      if (color[f] == side && board[f] == pawn)
  1072. X    LinkMove (ply, f, epsquare, capture | epmask, xside);
  1073. X    }
  1074. X  killt[SwagHt | sidebit] -= 5000;
  1075. X  killt[Swag0 | sidebit] -= 2000;
  1076. X  killt[Swag1 | sidebit] -= 60;
  1077. X  killt[Swag2 | sidebit] -= 50;
  1078. X  killt[Swag3 | sidebit] -= 40;
  1079. X  killt[Swag4 | sidebit] -= 30;
  1080. X  SwagHt = 0;            /* SwagHt is only used once */
  1081. X}
  1082. X
  1083. Xvoid
  1084. XCaptureList (register short int side, short int ply)
  1085. X
  1086. X/*
  1087. X * Fill the array Tree[] with all available cature and promote moves for side
  1088. X * to play. Array TrPnt[ply] contains the index into Tree[] of the first move
  1089. X * at a ply.
  1090. X */
  1091. X
  1092. X{
  1093. X  register short u, sq, xside;
  1094. X  register struct leaf *node;
  1095. X  register unsigned char *ppos, *pdir;
  1096. X  short i, piece, *PL, r7;
  1097. X
  1098. X  xside = side ^ 1;
  1099. X  TrP = &TrPnt[ply + 1];
  1100. X  *TrP = TrPnt[ply];
  1101. X  node = &Tree[*TrP];
  1102. X  r7 = rank7[side];
  1103. X  PL = PieceList[side];
  1104. X  sidebit = ((side == white) ? 0 : 0x80);
  1105. X  killt[SwagHt | sidebit] += 5000;
  1106. X  killt[Swag0 | sidebit] += 2000;
  1107. X  killt[Swag1 | sidebit] += 60;
  1108. X  killt[Swag2 | sidebit] += 50;
  1109. X  killt[Swag3 | sidebit] += 40;
  1110. X  killt[Swag4 | sidebit] += 30;
  1111. X  for (i = 0; i <= PieceCnt[side]; i++)
  1112. X    {
  1113. X      sq = PL[i];
  1114. X      piece = board[sq];
  1115. X      if (sweep[piece])
  1116. X    {
  1117. X      ppos = nextpos[piece][sq];
  1118. X      pdir = nextdir[piece][sq];
  1119. X      u = ppos[sq];
  1120. X      do
  1121. X        {
  1122. X          if (color[u] == neutral)
  1123. X        u = ppos[u];
  1124. X          else
  1125. X        {
  1126. X          if (color[u] == xside)
  1127. X            Link (sq, u, capture, value[board[u]] + svalue[board[u]] - piece);
  1128. X          u = pdir[u];
  1129. X        }
  1130. X      } while (u != sq);
  1131. X    }
  1132. X      else
  1133. X    {
  1134. X      pdir = nextdir[ptype[side][piece]][sq];
  1135. X      if (piece == pawn && row (sq) == r7)
  1136. X        {
  1137. X          u = pdir[sq];
  1138. X          if (color[u] == xside)
  1139. X        Link (sq, u, capture | promote | queen, valueQ);
  1140. X          u = pdir[u];
  1141. X          if (color[u] == xside)
  1142. X        {
  1143. X          Link (sq, u, capture | promote | queen, valueQ);
  1144. X#if defined OLDXBOARD  || defined GNU3 || defined CHESSTOO
  1145. X          Link (sq, u, promote | knight, valueN);
  1146. X          Link (sq, u, promote | rook, valueR);
  1147. X          Link (sq, u, promote | bishop, valueB);
  1148. X#endif
  1149. X        }
  1150. X          ppos = nextpos[ptype[side][piece]][sq];
  1151. X          u = ppos[sq];    /* also generate non capture promote */
  1152. X          if (color[u] == neutral)
  1153. X        {
  1154. X          Link (sq, u, promote | queen, valueQ);
  1155. X#if defined OLDXBOARD  || defined GNU3 || defined CHESSTOO
  1156. X          Link (sq, u, promote | knight, valueN);
  1157. X          Link (sq, u, promote | rook, valueR);
  1158. X          Link (sq, u, promote | bishop, valueB);
  1159. X#endif
  1160. X        }
  1161. X        }
  1162. X      else
  1163. X        {
  1164. X          u = pdir[sq];
  1165. X          do
  1166. X        {
  1167. X          if (color[u] == xside)
  1168. X            Link (sq, u, capture, value[board[u]] + svalue[board[u]] - piece);
  1169. X          u = pdir[u];
  1170. X          } while (u != sq);
  1171. X        }
  1172. X    }
  1173. X    }
  1174. X  killt[SwagHt | sidebit] -= 5000;
  1175. X  killt[Swag0 | sidebit] -= 2000;
  1176. X  killt[Swag1 | sidebit] -= 60;
  1177. X  killt[Swag2 | sidebit] -= 50;
  1178. X  killt[Swag3 | sidebit] -= 40;
  1179. X  killt[Swag4 | sidebit] -= 30;
  1180. X  SwagHt = 0;            /* SwagHt is only used once */
  1181. X}
  1182. END_OF_FILE
  1183. if test 7906 -ne `wc -c <'src/genmoves.c'`; then
  1184.     echo shar: \"'src/genmoves.c'\" unpacked with wrong size!
  1185. fi
  1186. # end of 'src/genmoves.c'
  1187. fi
  1188. if test -f 'src/main.c' -a "${1}" != "-c" ; then 
  1189.   echo shar: Will not clobber existing file \"'src/main.c'\"
  1190. else
  1191. echo shar: Extracting \"'src/main.c'\" \(8946 characters\)
  1192. sed "s/^X//" >'src/main.c' <<'END_OF_FILE'
  1193. X/*
  1194. X * main.c - C source for GNU CHESS
  1195. X *
  1196. X * Copyright (c) 1988,1989,1990 John Stanback
  1197. X * Copyright (c) 1992 Free Software Foundation
  1198. X *
  1199. X * This file is part of GNU CHESS.
  1200. X *
  1201. X * GNU Chess is free software; you can redistribute it and/or modify
  1202. X * it under the terms of the GNU General Public License as published by
  1203. X * the Free Software Foundation; either version 2, or (at your option)
  1204. X * any later version.
  1205. X *
  1206. X * GNU Chess is distributed in the hope that it will be useful,
  1207. X * but WITHOUT ANY WARRANTY; without even the implied warranty of
  1208. X * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  1209. X * GNU General Public License for more details.
  1210. X *
  1211. X * You should have received a copy of the GNU General Public License
  1212. X * along with GNU Chess; see the file COPYING.  If not, write to
  1213. X * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  1214. X */
  1215. X
  1216. X#include "version.h"
  1217. X#include "gnuchess.h"
  1218. X#include <signal.h>
  1219. Xchar *ColorStr[2];
  1220. Xchar *CP[CPSIZE];
  1221. X/*
  1222. X * In a networked enviroment gnuchess might be compiled on different hosts
  1223. X * with different random number generators, that is not acceptable if they
  1224. X * are going to share the same transposition table.
  1225. X */
  1226. Xunsigned long int next = 1;
  1227. X
  1228. Xunsigned int
  1229. Xurand (void)
  1230. X{
  1231. X  next *= 1103515245;
  1232. X  next += 12345;
  1233. X  return ((unsigned int) (next >> 16) & 0xFFFF);
  1234. X}
  1235. X
  1236. Xvoid
  1237. Xsrand (unsigned int seed)
  1238. X{
  1239. X  next = seed;
  1240. X}
  1241. X
  1242. Xunsigned long hashkey, hashbd;
  1243. Xstruct hashval hashcode[2][7][64];
  1244. X
  1245. X#ifdef ttblsz
  1246. Xstruct hashentry huge ttable[2][vttblsz + MAXrehash];
  1247. Xunsigned int ttblsize;
  1248. X#endif
  1249. X
  1250. X
  1251. Xchar savefile[128] = "";
  1252. Xchar listfile[128] = "";
  1253. X#if !defined NOHISTORY
  1254. Xunsigned char history[8192];
  1255. X#endif
  1256. Xshort rpthash[2][256];
  1257. Xstruct leaf Tree[TREE], *root;
  1258. Xshort TrPnt[MAXDEPTH];
  1259. Xshort PieceList[2][64], PawnCnt[2][8];
  1260. Xshort castld[2], Mvboard[64];
  1261. Xshort svalue[64];
  1262. Xstruct flags flag;
  1263. Xshort opponent, computer, WAwindow, WBwindow, BAwindow, BBwindow, dither, INCscore;
  1264. Xlong ResponseTime, ExtraTime, Level, et, et0, time0, ft;
  1265. Xlong NodeCnt, ETnodes, EvalNodes, HashCnt, HashAdd, FHashCnt, FHashAdd, HashCol,
  1266. X THashCol, filesz;
  1267. Xlong replus, reminus;
  1268. Xshort HashDepth = HASHDEPTH, HashMoveLimit = HASHMOVELIMIT;
  1269. Xshort player, xwndw, rehash;
  1270. Xstruct GameRec GameList[MAXMOVES + MAXDEPTH];
  1271. Xshort Sdepth, GameCnt, Game50, MaxSearchDepth;
  1272. Xshort epsquare, contempt;
  1273. Xint Book;
  1274. Xstruct TimeControlRec TimeControl;
  1275. Xshort TCflag, TCmoves, TCminutes, TCseconds, OperatorTime;
  1276. Xshort XCmoves[3], XCminutes[3], XCseconds[3], XC, XCmore;
  1277. Xconst short otherside[3] =
  1278. X{black, white, neutral};
  1279. Xunsigned short hint;
  1280. Xshort int TOflag;        /* force search re-init if we backup search */
  1281. X
  1282. Xshort mtl[2], pmtl[2], hung[2];
  1283. Xshort Pindex[64];
  1284. Xshort PieceCnt[2];
  1285. Xshort FROMsquare, TOsquare;
  1286. Xshort HasKnight[2], HasBishop[2], HasRook[2], HasQueen[2];
  1287. Xshort ChkFlag[MAXDEPTH], CptrFlag[MAXDEPTH], PawnThreat[MAXDEPTH];
  1288. Xshort Pscore[MAXDEPTH], Tscore[MAXDEPTH];
  1289. Xconst short qrook[3] =
  1290. X{0, 56, 0};
  1291. Xconst short krook[3] =
  1292. X{7, 63, 0};
  1293. Xconst short kingP[3] =
  1294. X{4, 60, 0};
  1295. Xconst short rank7[3] =
  1296. X{6, 1, 0};
  1297. Xconst short sweep[8] =
  1298. X{false, false, false, true, true, true, false, false};
  1299. Xunsigned short killr0[MAXDEPTH], killr1[MAXDEPTH];
  1300. Xunsigned short killr2[MAXDEPTH], killr3[MAXDEPTH];
  1301. Xunsigned short PV, SwagHt, Swag0, Swag1, Swag2, Swag3, Swag4, sidebit;
  1302. Xshort killt[0x4000];
  1303. Xconst short value[7] =
  1304. X{0, valueP, valueN, valueB, valueR, valueQ, valueK};
  1305. Xconst short control[7] =
  1306. X{0, ctlP, ctlN, ctlB, ctlR, ctlQ, ctlK};
  1307. Xshort stage, stage2, Developed[2];
  1308. XFILE *hashfile;
  1309. Xunsigned int starttime;
  1310. Xshort int ahead = true, hash = true;
  1311. X
  1312. X/* hmm.... shouldn`t main be moved to the interface routines */
  1313. Xint
  1314. Xmain (int argc, char **argv)
  1315. X{
  1316. X  char *xwin = 0;
  1317. X  char *Lang = NULL;
  1318. X  srand (starttime = ((unsigned int) time ((long *) 0)));    /* init urand */
  1319. X#ifdef ttblsz
  1320. X  ttblsize = ttblsz;
  1321. X  rehash = -1;
  1322. X#endif /* ttblsz */
  1323. X  if (argc > 2)
  1324. X    {
  1325. X      if (argv[1][0] == '-' && argv[1][1] == 'L')
  1326. X    {
  1327. X      Lang = argv[2];
  1328. X      argv += 2;
  1329. X      argc -= 2;
  1330. X    }
  1331. X    }
  1332. X  InitConst (Lang);
  1333. X  ColorStr[0] = CP[118];
  1334. X  ColorStr[1] = CP[119];
  1335. X
  1336. X  while (argc > 1 && ((argv[1][0] == '-') || (argv[1][0] == '+')))
  1337. X    {
  1338. X      switch (argv[1][1])
  1339. X    {
  1340. X    case 'a':
  1341. X      ahead = ((argv[1][0] == '-') ? false : true);
  1342. X      break;
  1343. X    case 'h':
  1344. X      hash = ((argv[1][0] == '-') ? false : true);
  1345. X      break;
  1346. X    case 's':
  1347. X      argc--;
  1348. X      argv++;
  1349. X      if (argc > 1)
  1350. X        strcpy (savefile, argv[1]);
  1351. X      break;
  1352. X    case 'l':
  1353. X      argc--;
  1354. X      argv++;
  1355. X      if (argc > 1)
  1356. X        strcpy (listfile, argv[1]);
  1357. X      break;
  1358. X
  1359. X#if ttblsz
  1360. X    case 'r':
  1361. X      if (argc > 2)
  1362. X        rehash = atoi (argv[2]);
  1363. X      argc--;
  1364. X      argv++;
  1365. X      if (rehash > MAXrehash)
  1366. X        rehash = MAXrehash;
  1367. X      break;
  1368. X    case 'T':
  1369. X      if (argc > 2)
  1370. X        ttblsize = atoi (argv[2]);
  1371. X      argc--;
  1372. X      argv++;
  1373. X      if (ttblsize > 0 && ttblsize < 24)
  1374. X        ttblsize = (1 << ttblsize);
  1375. X      else
  1376. X        ttblsize = ttblsz;
  1377. X      break;
  1378. X#ifdef HASHFILE
  1379. X    case 't':        /* create or test persistent transposition
  1380. X                 * table */
  1381. X      hashfile = fopen (HASHFILE, RWA_ACC);
  1382. X      if (hashfile)
  1383. X        {
  1384. X          fseek (hashfile, 0L, SEEK_END);
  1385. X          filesz = (ftell (hashfile) / sizeof (struct fileentry)) - 1;
  1386. X        }
  1387. X      if (hashfile != NULL)
  1388. X        {
  1389. X          long i, j;
  1390. X          int nr[MAXDEPTH];
  1391. X          struct fileentry n;
  1392. X
  1393. X          printf (CP[49]);
  1394. X          for (i = 0; i < MAXDEPTH; i++)
  1395. X        nr[i] = 0;
  1396. X          fseek (hashfile, 0L, SEEK_END);
  1397. X          i = ftell (hashfile) / sizeof (struct fileentry);
  1398. X          fseek (hashfile, 0L, SEEK_SET);
  1399. X          for (j = 0; j < i + 1; j++)
  1400. X        {
  1401. X          fread (&n, sizeof (struct fileentry), 1, hashfile);
  1402. X          if (n.depth)
  1403. X            {
  1404. X              nr[n.depth]++;
  1405. X              nr[0]++;
  1406. X            }
  1407. X        }
  1408. X          printf (CP[109],
  1409. X              nr[0], i);
  1410. X          for (j = 1; j < MAXDEPTH; j++)
  1411. X        printf ("%d ", nr[j]);
  1412. X          printf ("\n");
  1413. X        }
  1414. X      return 0;
  1415. X    case 'c':        /* create or test persistent transposition
  1416. X                 * table */
  1417. X      if (argc > 2)
  1418. X        filesz = atoi (argv[2]);
  1419. X      if (filesz > 0 && filesz < 24)
  1420. X        filesz = (1 << filesz) - 1 + MAXrehash;
  1421. X      else
  1422. X        filesz = Deffilesz + MAXrehash;
  1423. X      if ((hashfile = fopen (HASHFILE, RWA_ACC)) == NULL)
  1424. X        hashfile = fopen (HASHFILE, WA_ACC);
  1425. X      if (hashfile != NULL)
  1426. X        {
  1427. X          long j;
  1428. X          struct fileentry n;
  1429. X
  1430. X          printf (CP[66]);
  1431. X          for (j = 0; j < 32; j++)
  1432. X        n.bd[j] = 0;
  1433. X          n.f = n.t = 0;
  1434. X          n.flags = 0;
  1435. X          n.depth = 0;
  1436. X          n.sh = n.sl = 0;
  1437. X          for (j = 0; j < filesz + 1; j++)
  1438. X        fwrite (&n, sizeof (struct fileentry), 1, hashfile);
  1439. X          fclose (hashfile);
  1440. X        }
  1441. X      else
  1442. X        printf (CP[50], HASHFILE);
  1443. X      return (0);
  1444. X#endif /* HASHFILE */
  1445. X#endif /* ttblsz */
  1446. X    case 'x':
  1447. X      xwin = &argv[1][2];
  1448. X      break;
  1449. X    case 'v':
  1450. X      fprintf (stderr, CP[102], version, patchlevel);
  1451. X      exit ();
  1452. X    default:
  1453. X      fprintf (stderr, CP[103]);
  1454. X      exit ();
  1455. X    }
  1456. X      argv++;
  1457. X      argc--;
  1458. X    }
  1459. X  XC = 0;
  1460. X  Level = 0;
  1461. X#if defined CHESSTOOL || defined XBOARD
  1462. X  signal (SIGTERM, ExitChess);
  1463. X  TCflag = true;
  1464. X  TCmoves = 40;
  1465. X  TCminutes = 120;
  1466. X  TCseconds = 0;
  1467. X  OperatorTime = 0;
  1468. X#else
  1469. X  TCflag = false;
  1470. X  OperatorTime = 0;
  1471. X#endif
  1472. X  if (argc == 2)
  1473. X    {
  1474. X      if (argv[1][0] == ':')
  1475. X    {
  1476. X      TCseconds = atoi (&argv[1][1]);
  1477. X      if (TCseconds)
  1478. X        {
  1479. X          TCflag = true;
  1480. X          TCmoves = 1;
  1481. X          TCminutes = 0;
  1482. X        }
  1483. X    }
  1484. X      else
  1485. X    {
  1486. X      Level = MaxSearchDepth = atoi (argv[1]);
  1487. X      if (Level > MAXDEPTH)
  1488. X        Level = MaxSearchDepth = MAXDEPTH;
  1489. X    }
  1490. X    }
  1491. X  if (argc >= 3)
  1492. X    {
  1493. X      char *p;
  1494. X      if (argc > 9)
  1495. X    {
  1496. X      printf ("%s\n", CP[220]);
  1497. X      exit ();
  1498. X    }
  1499. X      TCmoves = atoi (argv[1]);
  1500. X      TCminutes = strtol (argv[2], &p, 10);
  1501. X      if (*p == ':')
  1502. X    TCseconds = strtol (p + 1, (char **) NULL, 10);
  1503. X      else
  1504. X    TCseconds = 0;
  1505. X      TCflag = true;
  1506. X      argc -= 3;
  1507. X      argv += 3;
  1508. X      while (argc > 1)
  1509. X    {
  1510. X      XCmoves[XC] = atoi (argv[0]);
  1511. X      XCminutes[XC] = strtol (argv[1], &p, 10);
  1512. X      if (*p == ':')
  1513. X        XCseconds[XC] = strtol (p + 1, (char **) NULL, 10);
  1514. X      else
  1515. X        XCseconds[XC] = 0;
  1516. X      if (XCmoves[XC] && (XCminutes[XC] || XCseconds[XC]))
  1517. X        XC++;
  1518. X      else
  1519. X        {
  1520. X          printf (CP[220]);
  1521. X          exit ();
  1522. X        }
  1523. X      argc -= 2;
  1524. X      argv += 2;
  1525. X    }
  1526. X      if (argc)
  1527. X    {
  1528. X      printf ("%s\n", CP[220]);
  1529. X      exit ();
  1530. X    }
  1531. X    }
  1532. X  Initialize ();
  1533. X#ifdef ttblsz
  1534. X  Initialize_ttable ();
  1535. X#endif /* ttblsz */
  1536. X  Initialize_dist ();
  1537. X  Initialize_moves ();
  1538. X  NewGame ();
  1539. X
  1540. X  flag.easy = ahead;
  1541. X  flag.hash = hash;
  1542. X  if (xwin)
  1543. X    xwndw = atoi (xwin);
  1544. X
  1545. X  hashfile = NULL;
  1546. X#if ttblsz
  1547. X#ifdef HASHFILE
  1548. X  hashfile = fopen (HASHFILE, RWA_ACC);
  1549. X  if (hashfile)
  1550. X    {
  1551. X      fseek (hashfile, 0L, SEEK_END);
  1552. X      filesz = ftell (hashfile) / sizeof (struct fileentry) - 1;
  1553. X    }
  1554. X#if !defined CHESSTOOL && !defined XBOARD
  1555. X  else
  1556. X    ShowMessage (CP[98]);
  1557. X#endif
  1558. X#endif /* HASHFILE */
  1559. X#endif /* ttblsz */
  1560. X  while (!(flag.quit))
  1561. X    {
  1562. X      if (flag.bothsides && !flag.mate)
  1563. X    SelectMove (opponent, 1);
  1564. X      else
  1565. X    InputCommand ();
  1566. X      if (!(flag.quit || flag.mate || flag.force))
  1567. X    {
  1568. X      SelectMove (computer, 1);
  1569. X    }
  1570. X    }
  1571. X#if ttblsz
  1572. X#ifdef HASHFILE
  1573. X  if (hashfile)
  1574. X    fclose (hashfile);
  1575. X#endif /* HASHFILE */
  1576. X#endif /* ttblsz */
  1577. X
  1578. X  ExitChess ();
  1579. X  return (0);
  1580. X}
  1581. END_OF_FILE
  1582. if test 8946 -ne `wc -c <'src/main.c'`; then
  1583.     echo shar: \"'src/main.c'\" unpacked with wrong size!
  1584. fi
  1585. # end of 'src/main.c'
  1586. fi
  1587. if test -f 'src/util.c' -a "${1}" != "-c" ; then 
  1588.   echo shar: Will not clobber existing file \"'src/util.c'\"
  1589. else
  1590. echo shar: Extracting \"'src/util.c'\" \(8883 characters\)
  1591. sed "s/^X//" >'src/util.c' <<'END_OF_FILE'
  1592. X/*
  1593. X * util.c - C source for GNU CHESS
  1594. X *
  1595. X * Copyright (c) 1988,1989,1990 John Stanback
  1596. X * Copyright (c) 1992 Free Software Foundation
  1597. X *
  1598. X * This file is part of GNU CHESS.
  1599. X *
  1600. X * GNU Chess is free software; you can redistribute it and/or modify
  1601. X * it under the terms of the GNU General Public License as published by
  1602. X * the Free Software Foundation; either version 2, or (at your option)
  1603. X * any later version.
  1604. X *
  1605. X * GNU Chess is distributed in the hope that it will be useful,
  1606. X * but WITHOUT ANY WARRANTY; without even the implied warranty of
  1607. X * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  1608. X * GNU General Public License for more details.
  1609. X *
  1610. X * You should have received a copy of the GNU General Public License
  1611. X * along with GNU Chess; see the file COPYING.  If not, write to
  1612. X * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  1613. X */
  1614. X#include "gnuchess.h"
  1615. Xextern char mvstr[4][6];
  1616. Xint
  1617. Xparse (FILE * fd, short unsigned int *mv, short int side, char *opening)
  1618. X{
  1619. X  register int c, i, r1, r2, c1, c2;
  1620. X  char s[128];
  1621. X  char *p;
  1622. X
  1623. X  while ((c = getc (fd)) == ' ' || c == '\n') ;
  1624. X  i = 0;
  1625. X  s[0] = (char) c;
  1626. X  if (c == '!')
  1627. X    {
  1628. X      p = opening;
  1629. X      do
  1630. X    {
  1631. X      *p++ = c;
  1632. X      c = getc (fd);
  1633. X      if (c == '\n' || c == EOF)
  1634. X        {
  1635. X          *p = '\0';
  1636. X          return 0;
  1637. X        }
  1638. X      } while (true);
  1639. X    }
  1640. X  while (c != '?' && c != ' ' && c != '\t' && c != '\n' && c != EOF)
  1641. X    s[++i] = (char) (c = getc (fd));
  1642. X  s[++i] = '\0';
  1643. X  if (c == EOF)
  1644. X    return (-1);
  1645. X  if (s[0] == '!' || s[0] == ';' || i < 3)
  1646. X    {
  1647. X      while (c != '\n' && c != EOF)
  1648. X    c = getc (fd);
  1649. X      return (0);
  1650. X    }
  1651. X  if (s[4] == 'o')
  1652. X    *mv = ((side == black) ? LONGBLACKCASTLE : LONGWHITECASTLE);
  1653. X  else if (s[0] == 'o')
  1654. X    *mv = ((side == black) ? BLACKCASTLE : WHITECASTLE);
  1655. X  else
  1656. X    {
  1657. X      c1 = s[0] - 'a';
  1658. X      r1 = s[1] - '1';
  1659. X      c2 = s[2] - 'a';
  1660. X      r2 = s[3] - '1';
  1661. X      *mv = (locn (r1, c1) << 8) | locn (r2, c2);
  1662. X    }
  1663. X  if (c == '?')
  1664. X    {                /* Bad move, not for the program to play */
  1665. X      *mv |= 0x8000;        /* Flag it ! */
  1666. X      c = getc (fd);
  1667. X    }
  1668. X  return (1);
  1669. X}
  1670. X
  1671. X
  1672. X#if ttblsz
  1673. X
  1674. X#define CB(i) (unsigned char) ((color[2 * (i)] ? 0x80 : 0)\
  1675. X           | (board[2 * (i)] << 4)\
  1676. X           | (color[2 * (i) + 1] ? 0x8 : 0)\
  1677. X           | (board[2 * (i) + 1]))
  1678. X
  1679. Xint
  1680. XProbeTTable (short int side,
  1681. X         short int depth,
  1682. X         short int ply,
  1683. X         short int *alpha,
  1684. X         short int *beta,
  1685. X         short int *score)
  1686. X
  1687. X/*
  1688. X * Look for the current board position in the transposition table.
  1689. X */
  1690. X
  1691. X{
  1692. X  register struct hashentry *ptbl;
  1693. X  register short i;
  1694. X
  1695. X  ptbl = &ttable[side][hashkey & (ttblsize - 1)];
  1696. X
  1697. X  /* rehash max rehash times */
  1698. X  for (i = 1; (ptbl->depth) && (ptbl->hashbd != hashbd) && (i <= rehash); i++)
  1699. X    ptbl++;
  1700. X  if ((ptbl->depth) && (ptbl->hashbd == hashbd))
  1701. X    {
  1702. X      HashCnt++;
  1703. X#ifdef HASHTEST
  1704. X      for (i = 0; i < 32; i++)
  1705. X    {
  1706. X      if (ptbl->bd[i] != CB (i))
  1707. X        {
  1708. X          HashCol++;
  1709. X          ShowMessage (CP[199]);    /*ttable collision detected*/
  1710. X          break;
  1711. X        }
  1712. X    }
  1713. X#endif /* HASHTEST */
  1714. X
  1715. X
  1716. X      SwagHt = ptbl->mv;
  1717. X      if ((short) ptbl->depth >= depth)
  1718. X    {
  1719. X      PV = ptbl->mv;
  1720. X      if (ptbl->flags & truescore)
  1721. X        {
  1722. X          *score = ptbl->score;
  1723. X          /* adjust *score so moves to mate is from root */
  1724. X          if (*score > 9000)
  1725. X        *score -= ply;
  1726. X          else if (*score < -9000)
  1727. X        *score += ply;
  1728. X          *beta = -20000;
  1729. X        }
  1730. X#if 0                /* Never happens! see search */
  1731. X      else if (ptbl->flags & upperbound)
  1732. X        {
  1733. X          if (ptbl->score < *beta)
  1734. X        *beta = ptbl->score + 1;
  1735. X        }
  1736. X#endif
  1737. X      else if (ptbl->flags & lowerbound)
  1738. X        {
  1739. X          if (ptbl->score > *alpha)
  1740. X        *alpha = *score - 1;
  1741. X        }
  1742. X      return (true);
  1743. X    }
  1744. X    }
  1745. X  return (false);
  1746. X}
  1747. X
  1748. Xint
  1749. XPutInTTable (short int side,
  1750. X         short int score,
  1751. X         short int depth,
  1752. X         short int ply,
  1753. X         short int alpha,
  1754. X         short int beta,
  1755. X         short unsigned int mv)
  1756. X
  1757. X/*
  1758. X * Store the current board position in the transposition table.
  1759. X */
  1760. X
  1761. X{
  1762. X  register struct hashentry *ptbl;
  1763. X  register short i;
  1764. X
  1765. X  ptbl = &ttable[side][hashkey & (ttblsize - 1)];
  1766. X
  1767. X  /* rehash max rehash times */
  1768. X  for (i = 1; ptbl->depth && ptbl->hashbd != hashbd && i <= rehash; i++)
  1769. X    ptbl++;
  1770. X  if (i > rehash)
  1771. X    THashCol++;
  1772. X  if (depth >= ptbl->depth || ptbl->hashbd != hashbd)
  1773. X    {
  1774. X      HashAdd++;
  1775. X      ptbl->hashbd = hashbd;
  1776. X      ptbl->depth = (unsigned char) depth;
  1777. X      /* adjust score so moves to mate is from this ply */
  1778. X      if (score > 9000)
  1779. X    score += ply;
  1780. X      else if (score < -9000)
  1781. X    score -= ply;
  1782. X      ptbl->score = score;
  1783. X      ptbl->mv = mv;
  1784. X#ifdef DEBUG4
  1785. X      if (debuglevel & 32)
  1786. X    {
  1787. X      algbr (mv >> 8, mv & 0xff, 0);
  1788. X      printf ("-add-> d=%d s=%d p=%d a=%d b=%d %s\n", depth, score, ply, alpha, beta, mvstr);
  1789. X    }
  1790. X#endif
  1791. X/*#ifdef notdef
  1792. X      if (score < alpha)
  1793. X    ptbl->flags = upperbound;
  1794. X      else
  1795. X/*#endif /* 0 */
  1796. X      if (score > beta)
  1797. X    {
  1798. X      ptbl->flags = lowerbound;
  1799. X      score = beta + 1;
  1800. X    }
  1801. X      else
  1802. X    ptbl->flags = truescore;
  1803. X
  1804. X#ifdef HASHTEST
  1805. X      for (i = 0; i < 32; i++)
  1806. X    {
  1807. X      ptbl->bd[i] = CB (i);
  1808. X    }
  1809. X#endif /* HASHTEST */
  1810. X      return true;
  1811. X    }
  1812. X  return false;
  1813. X}
  1814. X
  1815. Xvoid
  1816. XZeroTTable (void)
  1817. X{
  1818. X  register int a;
  1819. X  for (a = 0; a < ttblsize + rehash; a++)
  1820. X    {
  1821. X      ttable[white][a].depth = 0;
  1822. X      ttable[black][a].depth = 0;
  1823. X    }
  1824. X#ifdef notdef
  1825. X  register struct hashentry *ptbl;
  1826. X  for (ptbl = &ttable[white][0]; ptbl < &ttable[white][ttblsize + rehash]; ptbl++)
  1827. X    ptbl->depth = 0;
  1828. X  for (ptbl = &ttable[black][0]; ptbl < &ttable[white][ttblsize + rehash]; ptbl++)
  1829. X    ptbl->depth = 0;
  1830. X#endif
  1831. X}
  1832. X
  1833. X#ifdef HASHFILE
  1834. Xint
  1835. XProbeFTable (short int side,
  1836. X         short int depth,
  1837. X         short int ply,
  1838. X         short int *alpha,
  1839. X         short int *beta,
  1840. X         short int *score)
  1841. X
  1842. X/*
  1843. X * Look for the current board position in the persistent transposition table.
  1844. X */
  1845. X
  1846. X{
  1847. X  register short i, j;
  1848. X  register unsigned long hashix;
  1849. X  struct fileentry new, t;
  1850. X
  1851. X  hashix = ((side == white) ? (hashkey & 0xFFFFFFFE) : (hashkey | 1)) & filesz;
  1852. X
  1853. X  for (i = 0; i < 32; i++)
  1854. X    new.bd[i] = CB (i);
  1855. X  new.flags = 0;
  1856. X  if (Mvboard[kingP[side]] == 0)
  1857. X    {
  1858. X      if (Mvboard[qrook[side]] == 0)
  1859. X    new.flags |= queencastle;
  1860. X      if (Mvboard[krook[side]] == 0)
  1861. X    new.flags |= kingcastle;
  1862. X    }
  1863. X  for (i = 0; i < frehash; i++)
  1864. X    {
  1865. X      fseek (hashfile,
  1866. X         sizeof (struct fileentry) * ((hashix + 2 * i) & (filesz)),
  1867. X         SEEK_SET);
  1868. X      fread (&t, sizeof (struct fileentry), 1, hashfile);
  1869. X      if (!t.depth)
  1870. X    break;
  1871. X      for (j = 0; j < 32; j++)
  1872. X    if (t.bd[j] != new.bd[j])
  1873. X      break;
  1874. X      if (((short) t.depth >= depth) && (j >= 32)
  1875. X      && (new.flags == (t.flags & (kingcastle | queencastle))))
  1876. X    {
  1877. X      FHashCnt++;
  1878. X      PV = (t.f << 8) | t.t;
  1879. X      *score = (t.sh << 8) | t.sl;
  1880. X      /* adjust *score so moves to mate is from root */
  1881. X      if (*score > 9000)
  1882. X        *score -= ply;
  1883. X      else if (*score < -9000)
  1884. X        *score += ply;
  1885. X      if (t.flags & truescore)
  1886. X        {
  1887. X          *beta = -20000;
  1888. X        }
  1889. X      else if (t.flags & lowerbound)
  1890. X        {
  1891. X          if (*score > *alpha)
  1892. X        *alpha = *score - 1;
  1893. X        }
  1894. X      else if (t.flags & upperbound)
  1895. X        {
  1896. X          if (*score < *beta)
  1897. X        *beta = *score + 1;
  1898. X        }
  1899. X      return (true);
  1900. X    }
  1901. X    }
  1902. X  return (false);
  1903. X}
  1904. X
  1905. Xvoid
  1906. XPutInFTable (short int side,
  1907. X         short int score,
  1908. X         short int depth,
  1909. X         short int ply,
  1910. X         short int alpha,
  1911. X         short int beta,
  1912. X         short unsigned int f,
  1913. X         short unsigned int t)
  1914. X
  1915. X/*
  1916. X * Store the current board position in the persistent transposition table.
  1917. X */
  1918. X
  1919. X{
  1920. X  register unsigned short i;
  1921. X  register unsigned long hashix;
  1922. X  struct fileentry new, tmp;
  1923. X
  1924. X  FHashAdd++;
  1925. X  hashix = ((side == white) ? (hashkey & 0xFFFFFFFE) : (hashkey | 1)) & filesz;
  1926. X  for (i = 0; i < 32; i++)
  1927. X    new.bd[i] = CB (i);
  1928. X  new.f = (unsigned char) f;
  1929. X  new.t = (unsigned char) t;
  1930. X  if (score < alpha)
  1931. X    new.flags = upperbound;
  1932. X  else
  1933. X    new.flags = ((score > beta) ? lowerbound : truescore);
  1934. X  if (Mvboard[kingP[side]] == 0)
  1935. X    {
  1936. X      if (Mvboard[qrook[side]] == 0)
  1937. X    new.flags |= queencastle;
  1938. X      if (Mvboard[krook[side]] == 0)
  1939. X    new.flags |= kingcastle;
  1940. X    }
  1941. X  new.depth = (unsigned char) depth;
  1942. X  /* adjust *score so moves to mate is from root */
  1943. X  if (score > 9000)
  1944. X    score += ply;
  1945. X  else if (score < -9000)
  1946. X    score -= ply;
  1947. X
  1948. X
  1949. X  new.sh = (unsigned char) (score >> 8);
  1950. X  new.sl = (unsigned char) (score & 0xFF);
  1951. X
  1952. X  for (i = 0; i < frehash; i++)
  1953. X    {
  1954. X      fseek (hashfile,
  1955. X         sizeof (struct fileentry) * ((hashix + 2 * i) & (filesz)),
  1956. X         SEEK_SET);
  1957. X      fread (&tmp, sizeof (struct fileentry), 1, hashfile);
  1958. X      if ((short) tmp.depth <= depth)
  1959. X    {
  1960. X      fseek (hashfile,
  1961. X         sizeof (struct fileentry) * ((hashix + 2 * i) & (filesz)),
  1962. X         SEEK_SET);
  1963. X      fwrite (&new, sizeof (struct fileentry), 1, hashfile);
  1964. X      break;
  1965. X    }
  1966. X    }
  1967. X}
  1968. X
  1969. X#endif /* HASHFILE */
  1970. X#endif /* ttblsz */
  1971. X
  1972. Xvoid
  1973. XZeroRPT (void)
  1974. X{
  1975. X#ifdef NOMEMSET
  1976. X  register int side, i;
  1977. X  for (side = white; side <= black; side++)
  1978. X    for (i = 0; i < 256;)
  1979. X      rpthash[side][i++] = 0;
  1980. X#else
  1981. X   memset ((char *) rpthash, 0, sizeof (rpthash));
  1982. X#endif
  1983. X}
  1984. END_OF_FILE
  1985. if test 8883 -ne `wc -c <'src/util.c'`; then
  1986.     echo shar: \"'src/util.c'\" unpacked with wrong size!
  1987. fi
  1988. # end of 'src/util.c'
  1989. fi
  1990. echo shar: End of archive 11 \(of 12\).
  1991. cp /dev/null ark11isdone
  1992. MISSING=""
  1993. for I in 1 2 3 4 5 6 7 8 9 10 11 12 ; do
  1994.     if test ! -f ark${I}isdone ; then
  1995.     MISSING="${MISSING} ${I}"
  1996.     fi
  1997. done
  1998. if test "${MISSING}" = "" ; then
  1999.     echo You have unpacked all 12 archives.
  2000.     rm -f ark[1-9]isdone ark[1-9][0-9]isdone
  2001.     echo Building book file.
  2002.     cat misc/book.xaa misc/book.xab > misc/gnuchess.nunn.book
  2003.     rm misc/book.xaa misc/book.xab
  2004. else
  2005.     echo You still need to unpack the following archives:
  2006.     echo "        " ${MISSING}
  2007. fi
  2008. ##  End of shell archive.
  2009. exit 0
  2010.