home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / games / volume13 / gnuchess4 / part08 < prev    next >
Internet Message Format  |  1992-08-03  |  56KB
  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: v13i096:  gnuchess4 - GNU Chess 4.0, Part08/12
  5. Message-ID: <3063@master.CNA.TEK.COM>
  6. Date: 19 Jun 92 15:54:47 GMT
  7. Sender: news@master.CNA.TEK.COM
  8. Lines: 1849
  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 96
  13. Archive-name: gnuchess4/Part08
  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 8 (of 12)."
  26. # Contents:  doc/COPYING doc/TODO src/gnuan.c src/init.c
  27. # Wrapped by billr@saab on Fri Jun 19 08:36:02 1992
  28. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  29. if test -f 'doc/COPYING' -a "${1}" != "-c" ; then 
  30.   echo shar: Will not clobber existing file \"'doc/COPYING'\"
  31. else
  32. echo shar: Extracting \"'doc/COPYING'\" \(17976 characters\)
  33. sed "s/^X//" >'doc/COPYING' <<'END_OF_FILE'
  34. X            GNU GENERAL PUBLIC LICENSE
  35. X               Version 2, June 1991
  36. X
  37. X Copyright (C) 1989, 1991 Free Software Foundation, Inc.
  38. X                          675 Mass Ave, Cambridge, MA 02139, USA
  39. X Everyone is permitted to copy and distribute verbatim copies
  40. X of this license document, but changing it is not allowed.
  41. X
  42. X                Preamble
  43. X
  44. X  The licenses for most software are designed to take away your
  45. Xfreedom to share and change it.  By contrast, the GNU General Public
  46. XLicense is intended to guarantee your freedom to share and change free
  47. Xsoftware--to make sure the software is free for all its users.  This
  48. XGeneral Public License applies to most of the Free Software
  49. XFoundation's software and to any other program whose authors commit to
  50. Xusing it.  (Some other Free Software Foundation software is covered by
  51. Xthe GNU Library General Public License instead.)  You can apply it to
  52. Xyour programs, too.
  53. X
  54. X  When we speak of free software, we are referring to freedom, not
  55. Xprice.  Our General Public Licenses are designed to make sure that you
  56. Xhave the freedom to distribute copies of free software (and charge for
  57. Xthis service if you wish), that you receive source code or can get it
  58. Xif you want it, that you can change the software or use pieces of it
  59. Xin new free programs; and that you know you can do these things.
  60. X
  61. X  To protect your rights, we need to make restrictions that forbid
  62. Xanyone to deny you these rights or to ask you to surrender the rights.
  63. XThese restrictions translate to certain responsibilities for you if you
  64. Xdistribute copies of the software, or if you modify it.
  65. X
  66. X  For example, if you distribute copies of such a program, whether
  67. Xgratis or for a fee, you must give the recipients all the rights that
  68. Xyou have.  You must make sure that they, too, receive or can get the
  69. Xsource code.  And you must show them these terms so they know their
  70. Xrights.
  71. X
  72. X  We protect your rights with two steps: (1) copyright the software, and
  73. X(2) offer you this license which gives you legal permission to copy,
  74. Xdistribute and/or modify the software.
  75. X
  76. X  Also, for each author's protection and ours, we want to make certain
  77. Xthat everyone understands that there is no warranty for this free
  78. Xsoftware.  If the software is modified by someone else and passed on, we
  79. Xwant its recipients to know that what they have is not the original, so
  80. Xthat any problems introduced by others will not reflect on the original
  81. Xauthors' reputations.
  82. X
  83. X  Finally, any free program is threatened constantly by software
  84. Xpatents.  We wish to avoid the danger that redistributors of a free
  85. Xprogram will individually obtain patent licenses, in effect making the
  86. Xprogram proprietary.  To prevent this, we have made it clear that any
  87. Xpatent must be licensed for everyone's free use or not licensed at all.
  88. X
  89. X  The precise terms and conditions for copying, distribution and
  90. Xmodification follow.
  91. X
  92. X            GNU GENERAL PUBLIC LICENSE
  93. X   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
  94. X
  95. X  0. This License applies to any program or other work which contains
  96. Xa notice placed by the copyright holder saying it may be distributed
  97. Xunder the terms of this General Public License.  The "Program", below,
  98. Xrefers to any such program or work, and a "work based on the Program"
  99. Xmeans either the Program or any derivative work under copyright law:
  100. Xthat is to say, a work containing the Program or a portion of it,
  101. Xeither verbatim or with modifications and/or translated into another
  102. Xlanguage.  (Hereinafter, translation is included without limitation in
  103. Xthe term "modification".)  Each licensee is addressed as "you".
  104. X
  105. XActivities other than copying, distribution and modification are not
  106. Xcovered by this License; they are outside its scope.  The act of
  107. Xrunning the Program is not restricted, and the output from the Program
  108. Xis covered only if its contents constitute a work based on the
  109. XProgram (independent of having been made by running the Program).
  110. XWhether that is true depends on what the Program does.
  111. X
  112. X  1. You may copy and distribute verbatim copies of the Program's
  113. Xsource code as you receive it, in any medium, provided that you
  114. Xconspicuously and appropriately publish on each copy an appropriate
  115. Xcopyright notice and disclaimer of warranty; keep intact all the
  116. Xnotices that refer to this License and to the absence of any warranty;
  117. Xand give any other recipients of the Program a copy of this License
  118. Xalong with the Program.
  119. X
  120. XYou may charge a fee for the physical act of transferring a copy, and
  121. Xyou may at your option offer warranty protection in exchange for a fee.
  122. X
  123. X  2. You may modify your copy or copies of the Program or any portion
  124. Xof it, thus forming a work based on the Program, and copy and
  125. Xdistribute such modifications or work under the terms of Section 1
  126. Xabove, provided that you also meet all of these conditions:
  127. X
  128. X    a) You must cause the modified files to carry prominent notices
  129. X    stating that you changed the files and the date of any change.
  130. X
  131. X    b) You must cause any work that you distribute or publish, that in
  132. X    whole or in part contains or is derived from the Program or any
  133. X    part thereof, to be licensed as a whole at no charge to all third
  134. X    parties under the terms of this License.
  135. X
  136. X    c) If the modified program normally reads commands interactively
  137. X    when run, you must cause it, when started running for such
  138. X    interactive use in the most ordinary way, to print or display an
  139. X    announcement including an appropriate copyright notice and a
  140. X    notice that there is no warranty (or else, saying that you provide
  141. X    a warranty) and that users may redistribute the program under
  142. X    these conditions, and telling the user how to view a copy of this
  143. X    License.  (Exception: if the Program itself is interactive but
  144. X    does not normally print such an announcement, your work based on
  145. X    the Program is not required to print an announcement.)
  146. X
  147. XThese requirements apply to the modified work as a whole.  If
  148. Xidentifiable sections of that work are not derived from the Program,
  149. Xand can be reasonably considered independent and separate works in
  150. Xthemselves, then this License, and its terms, do not apply to those
  151. Xsections when you distribute them as separate works.  But when you
  152. Xdistribute the same sections as part of a whole which is a work based
  153. Xon the Program, the distribution of the whole must be on the terms of
  154. Xthis License, whose permissions for other licensees extend to the
  155. Xentire whole, and thus to each and every part regardless of who wrote it.
  156. X
  157. XThus, it is not the intent of this section to claim rights or contest
  158. Xyour rights to work written entirely by you; rather, the intent is to
  159. Xexercise the right to control the distribution of derivative or
  160. Xcollective works based on the Program.
  161. X
  162. XIn addition, mere aggregation of another work not based on the Program
  163. Xwith the Program (or with a work based on the Program) on a volume of
  164. Xa storage or distribution medium does not bring the other work under
  165. Xthe scope of this License.
  166. X
  167. X  3. You may copy and distribute the Program (or a work based on it,
  168. Xunder Section 2) in object code or executable form under the terms of
  169. XSections 1 and 2 above provided that you also do one of the following:
  170. X
  171. X    a) Accompany it with the complete corresponding machine-readable
  172. X    source code, which must be distributed under the terms of Sections
  173. X    1 and 2 above on a medium customarily used for software interchange; or,
  174. X
  175. X    b) Accompany it with a written offer, valid for at least three
  176. X    years, to give any third party, for a charge no more than your
  177. X    cost of physically performing source distribution, a complete
  178. X    machine-readable copy of the corresponding source code, to be
  179. X    distributed under the terms of Sections 1 and 2 above on a medium
  180. X    customarily used for software interchange; or,
  181. X
  182. X    c) Accompany it with the information you received as to the offer
  183. X    to distribute corresponding source code.  (This alternative is
  184. X    allowed only for noncommercial distribution and only if you
  185. X    received the program in object code or executable form with such
  186. X    an offer, in accord with Subsection b above.)
  187. X
  188. XThe source code for a work means the preferred form of the work for
  189. Xmaking modifications to it.  For an executable work, complete source
  190. Xcode means all the source code for all modules it contains, plus any
  191. Xassociated interface definition files, plus the scripts used to
  192. Xcontrol compilation and installation of the executable.  However, as a
  193. Xspecial exception, the source code distributed need not include
  194. Xanything that is normally distributed (in either source or binary
  195. Xform) with the major components (compiler, kernel, and so on) of the
  196. Xoperating system on which the executable runs, unless that component
  197. Xitself accompanies the executable.
  198. X
  199. XIf distribution of executable or object code is made by offering
  200. Xaccess to copy from a designated place, then offering equivalent
  201. Xaccess to copy the source code from the same place counts as
  202. Xdistribution of the source code, even though third parties are not
  203. Xcompelled to copy the source along with the object code.
  204. X
  205. X  4. You may not copy, modify, sublicense, or distribute the Program
  206. Xexcept as expressly provided under this License.  Any attempt
  207. Xotherwise to copy, modify, sublicense or distribute the Program is
  208. Xvoid, and will automatically terminate your rights under this License.
  209. XHowever, parties who have received copies, or rights, from you under
  210. Xthis License will not have their licenses terminated so long as such
  211. Xparties remain in full compliance.
  212. X
  213. X  5. You are not required to accept this License, since you have not
  214. Xsigned it.  However, nothing else grants you permission to modify or
  215. Xdistribute the Program or its derivative works.  These actions are
  216. Xprohibited by law if you do not accept this License.  Therefore, by
  217. Xmodifying or distributing the Program (or any work based on the
  218. XProgram), you indicate your acceptance of this License to do so, and
  219. Xall its terms and conditions for copying, distributing or modifying
  220. Xthe Program or works based on it.
  221. X
  222. X  6. Each time you redistribute the Program (or any work based on the
  223. XProgram), the recipient automatically receives a license from the
  224. Xoriginal licensor to copy, distribute or modify the Program subject to
  225. Xthese terms and conditions.  You may not impose any further
  226. Xrestrictions on the recipients' exercise of the rights granted herein.
  227. XYou are not responsible for enforcing compliance by third parties to
  228. Xthis License.
  229. X
  230. X  7. If, as a consequence of a court judgment or allegation of patent
  231. Xinfringement or for any other reason (not limited to patent issues),
  232. Xconditions are imposed on you (whether by court order, agreement or
  233. Xotherwise) that contradict the conditions of this License, they do not
  234. Xexcuse you from the conditions of this License.  If you cannot
  235. Xdistribute so as to satisfy simultaneously your obligations under this
  236. XLicense and any other pertinent obligations, then as a consequence you
  237. Xmay not distribute the Program at all.  For example, if a patent
  238. Xlicense would not permit royalty-free redistribution of the Program by
  239. Xall those who receive copies directly or indirectly through you, then
  240. Xthe only way you could satisfy both it and this License would be to
  241. Xrefrain entirely from distribution of the Program.
  242. X
  243. XIf any portion of this section is held invalid or unenforceable under
  244. Xany particular circumstance, the balance of the section is intended to
  245. Xapply and the section as a whole is intended to apply in other
  246. Xcircumstances.
  247. X
  248. XIt is not the purpose of this section to induce you to infringe any
  249. Xpatents or other property right claims or to contest validity of any
  250. Xsuch claims; this section has the sole purpose of protecting the
  251. Xintegrity of the free software distribution system, which is
  252. Ximplemented by public license practices.  Many people have made
  253. Xgenerous contributions to the wide range of software distributed
  254. Xthrough that system in reliance on consistent application of that
  255. Xsystem; it is up to the author/donor to decide if he or she is willing
  256. Xto distribute software through any other system and a licensee cannot
  257. Ximpose that choice.
  258. X
  259. XThis section is intended to make thoroughly clear what is believed to
  260. Xbe a consequence of the rest of this License.
  261. X
  262. X  8. If the distribution and/or use of the Program is restricted in
  263. Xcertain countries either by patents or by copyrighted interfaces, the
  264. Xoriginal copyright holder who places the Program under this License
  265. Xmay add an explicit geographical distribution limitation excluding
  266. Xthose countries, so that distribution is permitted only in or among
  267. Xcountries not thus excluded.  In such case, this License incorporates
  268. Xthe limitation as if written in the body of this License.
  269. X
  270. X  9. The Free Software Foundation may publish revised and/or new versions
  271. Xof the General Public License from time to time.  Such new versions will
  272. Xbe similar in spirit to the present version, but may differ in detail to
  273. Xaddress new problems or concerns.
  274. X
  275. XEach version is given a distinguishing version number.  If the Program
  276. Xspecifies a version number of this License which applies to it and "any
  277. Xlater version", you have the option of following the terms and conditions
  278. Xeither of that version or of any later version published by the Free
  279. XSoftware Foundation.  If the Program does not specify a version number of
  280. Xthis License, you may choose any version ever published by the Free Software
  281. XFoundation.
  282. X
  283. X  10. If you wish to incorporate parts of the Program into other free
  284. Xprograms whose distribution conditions are different, write to the author
  285. Xto ask for permission.  For software which is copyrighted by the Free
  286. XSoftware Foundation, write to the Free Software Foundation; we sometimes
  287. Xmake exceptions for this.  Our decision will be guided by the two goals
  288. Xof preserving the free status of all derivatives of our free software and
  289. Xof promoting the sharing and reuse of software generally.
  290. X
  291. X                NO WARRANTY
  292. X
  293. X  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
  294. XFOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
  295. XOTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
  296. XPROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
  297. XOR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  298. XMERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
  299. XTO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
  300. XPROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
  301. XREPAIR OR CORRECTION.
  302. X
  303. X  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
  304. XWILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
  305. XREDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
  306. XINCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
  307. XOUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
  308. XTO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
  309. XYOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
  310. XPROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
  311. XPOSSIBILITY OF SUCH DAMAGES.
  312. X
  313. X             END OF TERMS AND CONDITIONS
  314. X
  315. X        How to Apply These Terms to Your New Programs
  316. X
  317. X  If you develop a new program, and you want it to be of the greatest
  318. Xpossible use to the public, the best way to achieve this is to make it
  319. Xfree software which everyone can redistribute and change under these terms.
  320. X
  321. X  To do so, attach the following notices to the program.  It is safest
  322. Xto attach them to the start of each source file to most effectively
  323. Xconvey the exclusion of warranty; and each file should have at least
  324. Xthe "copyright" line and a pointer to where the full notice is found.
  325. X
  326. X    <one line to give the program's name and a brief idea of what it does.>
  327. X    Copyright (C) 19yy  <name of author>
  328. X
  329. X    This program is free software; you can redistribute it and/or modify
  330. X    it under the terms of the GNU General Public License as published by
  331. X    the Free Software Foundation; either version 2 of the License, or
  332. X    (at your option) any later version.
  333. X
  334. X    This program is distributed in the hope that it will be useful,
  335. X    but WITHOUT ANY WARRANTY; without even the implied warranty of
  336. X    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  337. X    GNU General Public License for more details.
  338. X
  339. X    You should have received a copy of the GNU General Public License
  340. X    along with this program; if not, write to the Free Software
  341. X    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  342. X
  343. XAlso add information on how to contact you by electronic and paper mail.
  344. X
  345. XIf the program is interactive, make it output a short notice like this
  346. Xwhen it starts in an interactive mode:
  347. X
  348. X    Gnomovision version 69, Copyright (C) 19yy name of author
  349. X    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
  350. X    This is free software, and you are welcome to redistribute it
  351. X    under certain conditions; type `show c' for details.
  352. X
  353. XThe hypothetical commands `show w' and `show c' should show the appropriate
  354. Xparts of the General Public License.  Of course, the commands you use may
  355. Xbe called something other than `show w' and `show c'; they could even be
  356. Xmouse-clicks or menu items--whatever suits your program.
  357. X
  358. XYou should also get your employer (if you work as a programmer) or your
  359. Xschool, if any, to sign a "copyright disclaimer" for the program, if
  360. Xnecessary.  Here is a sample; alter the names:
  361. X
  362. X  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
  363. X  `Gnomovision' (which makes passes at compilers) written by James Hacker.
  364. X
  365. X  <signature of Ty Coon>, 1 April 1989
  366. X  Ty Coon, President of Vice
  367. X
  368. XThis General Public License does not permit incorporating your program into
  369. Xproprietary programs.  If your program is a subroutine library, you may
  370. Xconsider it more useful to permit linking proprietary applications with the
  371. Xlibrary.  If this is what you want to do, use the GNU Library General
  372. XPublic License instead of this License.
  373. END_OF_FILE
  374. if test 17976 -ne `wc -c <'doc/COPYING'`; then
  375.     echo shar: \"'doc/COPYING'\" unpacked with wrong size!
  376. fi
  377. # end of 'doc/COPYING'
  378. fi
  379. if test -f 'doc/TODO' -a "${1}" != "-c" ; then 
  380.   echo shar: Will not clobber existing file \"'doc/TODO'\"
  381. else
  382. echo shar: Extracting \"'doc/TODO'\" \(1459 characters\)
  383. sed "s/^X//" >'doc/TODO' <<'END_OF_FILE'
  384. XFixup the dos makefile and check it out on dos.
  385. X
  386. Xallow shortend algebraic moves in book.
  387. XRemove opening lines gnuchess doesn't play well.
  388. X
  389. XThe hint problem.  If the hint is a promotion move easy mode
  390. Xdoesnt work right. It is currently bypassed in this case.
  391. XSearch doesn't save the fact its a promotion move in the
  392. XPV. So hint and post only show the move without the piece
  393. Xbeing promoted to. Cannot do easy mode off, because it must
  394. Xknow the piece being promoted to. Somehow should save it in PV.
  395. XAlso true for hashtable entries. flags are not saved they should
  396. Xbe.
  397. X
  398. XSomething is wrong with the time calculation, sometimes the number
  399. Xof moves to the next time control is set to -1.
  400. X1. e4 d6 2. d4 Nf6 3. white go make this happen.
  401. X
  402. XMake the timing function more flexible.
  403. XI would like to be able to have n time controls all different.
  404. XI would like to include the Fischer clock.
  405. XMake the timing function smarter.
  406. XAllow extra time whenever the score is changing a lot
  407. XUse the current depth as a parameter.
  408. X(the closer to zero it start the more a change should count)
  409. XIf the opponent seem to have made a blunder it might be a trap.
  410. XIf gnuchess is getting behind there might be a way out. (try to find it)
  411. X
  412. XAdd languages to the language file.
  413. X
  414. XImprove performace by modifying the search extension logic.
  415. X
  416. XMake the hash table include castling flags + ep flag.
  417. XCurrently only the transposition file include any of these and
  418. Xthen only castling for the side to move.
  419. END_OF_FILE
  420. if test 1459 -ne `wc -c <'doc/TODO'`; then
  421.     echo shar: \"'doc/TODO'\" unpacked with wrong size!
  422. fi
  423. # end of 'doc/TODO'
  424. fi
  425. if test -f 'src/gnuan.c' -a "${1}" != "-c" ; then 
  426.   echo shar: Will not clobber existing file \"'src/gnuan.c'\"
  427. else
  428. echo shar: Extracting \"'src/gnuan.c'\" \(20399 characters\)
  429. sed "s/^X//" >'src/gnuan.c' <<'END_OF_FILE'
  430. X/*
  431. X * gnuan.c - Analysis interface for gnuchess.
  432. X *
  433. X * Copyright (c) 1988,1989,1990 John Stanback
  434. X * Copyright (c) 1992 Free Software Foundation
  435. X *
  436. X * This file is part of GNU CHESS.
  437. X *
  438. X * GNU Chess is free software; you can redistribute it and/or modify
  439. X * it under the terms of the GNU General Public License as published by
  440. X * the Free Software Foundation; either version 2, or (at your option)
  441. X * any later version.
  442. X *
  443. X * GNU Chess is distributed in the hope that it will be useful,
  444. X * but WITHOUT ANY WARRANTY; without even the implied warranty of
  445. X * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  446. X * GNU General Public License for more details.
  447. X *
  448. X * You should have received a copy of the GNU General Public License
  449. X * along with GNU Chess; see the file COPYING.  If not, write to
  450. X * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  451. X */
  452. X
  453. X/*
  454. X * This is a front end for a chess analysis program.  It takes a file of
  455. X * moves in algebraic notation and creates a file containing each move that
  456. X * was made, the move it would have made, the score it would give itself
  457. X * after making the move it recommended, and the depth it searched for the
  458. X * move.
  459. X *
  460. X * This is a modification of nondsp.c.  I have cut out code that was not needed
  461. X * for this application such as the help and edit functions.  Most of the
  462. X * modifications were done in InputCommand.
  463. X */
  464. X
  465. X/*
  466. X * This file will generate two different analysis programs.  One is meant to
  467. X * be run as a background process inwhich the in and out files are
  468. X * predefined. The other is meant to be run in the foreground where it will
  469. X * prompt you for the name of the file with the game in it, the maximum depth
  470. X * the search should be conducted to and the time limit per move.  It would
  471. X * be nice to be able to give these parameters on the command line, but that
  472. X * would mean changing main which is in the gnuchess.c file.
  473. X *
  474. X * For each move it will analyse the move until either it has run out of time or
  475. X * it has reached the maximum depth.
  476. X *
  477. X * To build the version for background processing define BACKGROUND_ANALYSIS
  478. X * either at the top of this file, or in compilation.  The files and depth
  479. X * used are defined below.  They are MAX_DEPTH, MAX_TIME, OUT_FILE, IN_FILE
  480. X * and PROG_FILE.  The PROG_FILE is a file that will be updated as each move
  481. X * is analysed so you can check its progress.  This is only updated when
  482. X * running the BACKGROUND_ANALYSIS version.  In the version where the
  483. X * filename and depth are entered at runtime, the output goes to stdout.
  484. X */
  485. X
  486. X/* #define BACKGROUND_ANALYSIS 1 */
  487. X
  488. X#define MAX_DEPTH  15
  489. X#define MAX_TIME   20
  490. X#define OUT_FILE   "/pad/gnuan.out"
  491. X#define IN_FILE    "/pad/gnuan.in"
  492. X#define PROG_FILE  "/pad/gnuan.prog"
  493. X
  494. X
  495. X#include <ctype.h>
  496. X#include <signal.h>
  497. X#ifdef MSDOS
  498. X#include <dos.h>
  499. X#include <conio.h>
  500. X#include <stdlib.h>
  501. X#include <string.h>
  502. X#include <time.h>
  503. X#else
  504. X#include <sys/param.h>
  505. X#include <sys/types.h>
  506. X#include <sys/file.h>
  507. X#include <sys/ioctl.h>
  508. Xvoid TerminateSearch (int), Die (int);
  509. X
  510. X#endif /* MSDOS */
  511. X
  512. X#include "gnuchess.h"
  513. X#include "ataks.h"
  514. X#undef rxx
  515. X#undef cxx
  516. X#undef scanz
  517. X#undef printz
  518. X
  519. X#define rxx "12345678"
  520. X#define cxx "abcdefgh"
  521. X#define scanz scanf
  522. X#define printz printf
  523. X
  524. Xchar mvstr[4][6];
  525. Xchar *ColorStr[2] =
  526. X{"White", "Black"};
  527. Xint mycnt1, mycnt2;
  528. X
  529. Xstatic FILE *fpin;
  530. Xstatic FILE *fpout;
  531. Xchar *DRAW;
  532. Xunsigned short int MV[MAXDEPTH];
  533. Xenum
  534. X{
  535. X  XBOARD, GNUCHESS, OTHER
  536. X} InFileType;
  537. Xchar InBuf[256];
  538. X
  539. X#ifdef BACKGROUND_ANALYSIS
  540. Xstatic FILE *fpprog;
  541. X
  542. X#endif
  543. Xstatic char white_actual_move[20];
  544. Xstatic char black_actual_move[20];
  545. Xstatic char white_suggest_move[20];
  546. Xstatic char black_suggest_move[20];
  547. Xstatic int white_score;
  548. Xstatic int black_score;
  549. Xstatic int white_moving;
  550. Xstatic int current_depth;
  551. Xstatic int current_score;
  552. Xstatic int enable_update_display = 0;
  553. X
  554. X
  555. Xvoid
  556. XInitialize (void)
  557. X{
  558. X  mycnt1 = mycnt2 = 0;
  559. X}
  560. X
  561. Xvoid
  562. XExitChess (void)
  563. X{
  564. X  ListGame ();
  565. X  exit (0);
  566. X}
  567. X
  568. X#ifndef MSDOS            /* never called!!! */
  569. Xvoid
  570. XDie (int sig)
  571. X{
  572. X  ExitChess ();
  573. X}
  574. X
  575. X#endif /* MSDOS */
  576. X
  577. Xvoid
  578. XTerminateSearch (int sig)
  579. X{
  580. X#ifdef MSDOS
  581. X  sig++;            /* shut up the compiler */
  582. X#endif /* MSDOS */
  583. X  if (!flag.timeout)
  584. X    flag.musttimeout = true;
  585. X  flag.bothsides = false;
  586. X}
  587. X
  588. Xvoid
  589. Xalgbr (short int f, short int t, short int flag)
  590. X
  591. X/*
  592. X * Generate move strings in different formats.
  593. X */
  594. X
  595. X{
  596. X  int m3p;
  597. X
  598. X  if (f != t)
  599. X    {
  600. X      /* algebraic notation */
  601. X      mvstr[0][0] = cxx[column (f)];
  602. X      mvstr[0][1] = rxx[row (f)];
  603. X      mvstr[0][2] = cxx[column (t)];
  604. X      mvstr[0][3] = rxx[row (t)];
  605. X      mvstr[0][4] = mvstr[3][0] = '\0';
  606. X      if (((mvstr[1][0] = pxx[board[f]]) == 'P') || (flag & promote))
  607. X    {
  608. X      if (mvstr[0][0] == mvstr[0][2])    /* pawn did not eat */
  609. X        {
  610. X          mvstr[2][0] = mvstr[1][0] = mvstr[0][2];    /* to column */
  611. X          mvstr[2][1] = mvstr[1][1] = mvstr[0][3];    /* to row */
  612. X          m3p = 2;
  613. X        }
  614. X      else
  615. X        /* pawn ate */
  616. X        {
  617. X          mvstr[2][0] = mvstr[1][0] = mvstr[0][0];    /* from column */
  618. X          mvstr[2][1] = mvstr[1][1] = mvstr[0][2];    /* to column */
  619. X          mvstr[2][2] = mvstr[0][3];
  620. X          m3p = 3;        /* to row */
  621. X        }
  622. X      mvstr[2][m3p] = mvstr[1][2] = '\0';
  623. X      if (flag & promote)
  624. X        {
  625. X          mvstr[0][4] = mvstr[1][2] = mvstr[2][m3p] = qxx[flag & pmask];
  626. X          mvstr[1][3] = mvstr[2][m3p + 1] = mvstr[0][5] = '\0';
  627. X        }
  628. X    }
  629. X      else
  630. X    /* not a pawn */
  631. X    {
  632. X      mvstr[2][0] = mvstr[1][0];
  633. X      mvstr[2][1] = mvstr[0][1];
  634. X      mvstr[2][2] = mvstr[1][1] = mvstr[0][2];    /* to column */
  635. X      mvstr[2][3] = mvstr[1][2] = mvstr[0][3];    /* to row */
  636. X      mvstr[2][4] = mvstr[1][3] = '\0';
  637. X      strcpy (mvstr[3], mvstr[2]);
  638. X      mvstr[3][1] = mvstr[0][0];
  639. X      if (flag & cstlmask)
  640. X        {
  641. X          if (t > f)
  642. X        {
  643. X          strcpy (mvstr[1], "o-o");
  644. X          strcpy (mvstr[2], "O-O");
  645. X        }
  646. X          else
  647. X        {
  648. X          strcpy (mvstr[1], "o-o-o");
  649. X          strcpy (mvstr[2], "O-O-O");
  650. X        }
  651. X        }
  652. X    }
  653. X    }
  654. X  else
  655. X    mvstr[0][0] = mvstr[1][0] = mvstr[2][0] = mvstr[3][0] = '\0';
  656. X}
  657. X
  658. X
  659. Xint
  660. XVerifyMove (char *s, short int iop, unsigned short int *mv)
  661. X
  662. X/*
  663. X * Compare the string 's' to the list of legal moves available for the
  664. X * opponent. If a match is found, make the move on the board.
  665. X */
  666. X
  667. X{
  668. X  static short pnt, tempb, tempc, tempsf, tempst, cnt;
  669. X  static struct leaf xnode;
  670. X  struct leaf *node;
  671. X
  672. X  *mv = 0;
  673. X  if (iop == 2)
  674. X    {
  675. X      UnmakeMove (opponent, &xnode, &tempb, &tempc, &tempsf, &tempst);
  676. X      return (false);
  677. X    }
  678. X  cnt = 0;
  679. X  MoveList (opponent, 2);
  680. X  pnt = TrPnt[2];
  681. X  while (pnt < TrPnt[3])
  682. X    {
  683. X      node = &Tree[pnt++];
  684. X      algbr (node->f, node->t, (short) node->flags);
  685. X      if (strcmp (s, mvstr[0]) == 0 || strcmp (s, mvstr[1]) == 0 ||
  686. X      strcmp (s, mvstr[2]) == 0 || strcmp (s, mvstr[3]) == 0)
  687. X    {
  688. X      cnt++;
  689. X      xnode = *node;
  690. X    }
  691. X    }
  692. X  if (cnt == 1)
  693. X    {
  694. X      MakeMove (opponent, &xnode, &tempb, &tempc, &tempsf, &tempst, &INCscore);
  695. X      if (SqAtakd (PieceList[opponent][0], computer))
  696. X    {
  697. X      UnmakeMove (opponent, &xnode, &tempb, &tempc, &tempsf, &tempst);
  698. X      printz ("Illegal move\n");
  699. X      return (false);
  700. X    }
  701. X      else
  702. X    {
  703. X      if (iop == 1)
  704. X        return (true);
  705. X
  706. X      /*
  707. X           * UpdateDisplay (xnode.f, xnode.t, 0, (short) xnode.flags);
  708. X           */
  709. X      if ((board[xnode.t] == pawn)
  710. X          || (xnode.flags & capture)
  711. X          || (xnode.flags & cstlmask))
  712. X        {
  713. X          Game50 = GameCnt;
  714. X          ZeroRPT ();
  715. X        }
  716. X      GameList[GameCnt].depth = GameList[GameCnt].score = 0;
  717. X      GameList[GameCnt].nodes = 0;
  718. X      ElapsedTime (1);
  719. X      GameList[GameCnt].time = (short) et;
  720. X      TimeControl.clock[opponent] -= et;
  721. X      --TimeControl.moves[opponent];
  722. X      *mv = (xnode.f << 8) | xnode.t;
  723. X      algbr (xnode.f, xnode.t, false);
  724. X      return (true);
  725. X    }
  726. X    }
  727. X#ifdef CHESSTOOL
  728. X  printz ("Illegal move\n");
  729. X#else
  730. X  if (cnt > 1)
  731. X    ShowMessage ("Ambiguous Move!");
  732. X#endif
  733. X  return (false);
  734. X}
  735. X
  736. Xvoid
  737. Xhelp (void)
  738. X{
  739. X}
  740. X
  741. Xvoid
  742. XEditBoard (void)
  743. X
  744. X/*
  745. X * Set up a board position. Pieces are entered by typing the piece followed
  746. X * by the location. For example, Nf3 will place a knight on square f3.
  747. X */
  748. X
  749. X{
  750. X}
  751. X
  752. Xvoid
  753. XSetupBoard (void)
  754. X
  755. X/*
  756. X * Compatibility with Unix chess and the nchesstool. Set up a board position.
  757. X * Eight lines of eight characters are used to setup the board. a8-h8 is the
  758. X * first line. Black pieces are  represented  by  uppercase characters.
  759. X */
  760. X
  761. X{
  762. X}
  763. X
  764. Xvoid
  765. XShowDepth (char ch)
  766. X{
  767. X#ifdef MSDOS
  768. X  ch++;                /* shut up the compiler */
  769. X#endif /* MSDOS */
  770. X}
  771. X
  772. Xvoid
  773. XShowResults (short int score, unsigned short int *bstline, char ch)
  774. X{
  775. X  int i;
  776. X
  777. X  current_score = score;
  778. X  current_depth = Sdepth;
  779. X  for (i = 1; bstline[i] > 0; i++)
  780. X    {
  781. X      MV[i] = bstline[i];
  782. X    } MV[i] = 0;
  783. X}
  784. X
  785. Xvoid
  786. XSearchStartStuff (short int side)
  787. X{
  788. X  signal (SIGINT, TerminateSearch);
  789. X#ifndef MSDOS
  790. X  signal (SIGQUIT, TerminateSearch);
  791. X#endif /* MSDOS */
  792. X  if (flag.post)
  793. X    {
  794. X      fprintf (stderr, "\nMove# %d    Target= %ld    Clock: %ld\n",
  795. X           TCmoves - TimeControl.moves[side] + 1,
  796. X           ResponseTime, TimeControl.clock[side]);
  797. X    }
  798. X}
  799. X
  800. Xvoid
  801. XOutputMove (void)
  802. X{
  803. X  if (white_moving)
  804. X    {
  805. X      strcpy (white_suggest_move, mvstr[0]);
  806. X      white_score = current_score;
  807. X    }
  808. X  else
  809. X    {
  810. X      strcpy (black_suggest_move, mvstr[0]);
  811. X      black_score = current_score;
  812. X    }
  813. X}
  814. X
  815. Xvoid
  816. XElapsedTime (short int iop)
  817. X
  818. X/*
  819. X * Determine the time that has passed since the search was started. If the
  820. X * elapsed time exceeds the target (ResponseTime+ExtraTime) then set timeout
  821. X * to true which will terminate the search.
  822. X */
  823. X{
  824. X  if (ahead)
  825. X    {
  826. X#ifndef MSDOS
  827. X#ifdef FIONREAD
  828. X      long nchar;
  829. X
  830. X      ioctl (0, FIONREAD, &nchar);
  831. X      if (nchar)
  832. X    {
  833. X      flag.timeout = true;
  834. X      flag.bothsides = false;
  835. X    }
  836. X#endif
  837. X#else
  838. X      if (kbhit ())
  839. X    {
  840. X      flag.timeout = true;
  841. X      flag.bothsides = false;
  842. X    }
  843. X#endif /* MSDOS */
  844. X    }
  845. X  et = (time ((long *) 0) - time0) * 100;
  846. X  if (et < 0)
  847. X    et = 0;
  848. X  ETnodes += ZNODES;
  849. X  if (iop == 1)
  850. X    {
  851. X      if (et > ResponseTime + ExtraTime && Sdepth > 1)
  852. X    flag.timeout = true;
  853. X      time0 = time ((long *) 0);
  854. X      ETnodes = NodeCnt + ZNODES;
  855. X    }
  856. X}
  857. X
  858. Xvoid
  859. XSetTimeControl (void)
  860. X{
  861. X  if (TCflag)
  862. X    {
  863. X      TimeControl.moves[white] = TimeControl.moves[black] = TCmoves;
  864. X      TimeControl.clock[white] = TimeControl.clock[black] = 6000L * TCminutes;
  865. X    }
  866. X  else
  867. X    {
  868. X      TimeControl.moves[white] = TimeControl.moves[black] = 0;
  869. X      TimeControl.clock[white] = TimeControl.clock[black] = 0;
  870. X      Level = 600000L * TCminutes;
  871. X    }
  872. X  et = 0;
  873. X  ElapsedTime (1);
  874. X}
  875. X
  876. Xvoid
  877. XClrScreen (void)
  878. X{
  879. X#ifndef CHESSTOOL
  880. X  printz ("\n");
  881. X#endif
  882. X}
  883. X
  884. Xvoid
  885. XUpdateDisplay (short int f, short int t, short int redraw, short int isspec)
  886. X{
  887. X#ifndef CHESSTOOL
  888. X  short r, c, l;
  889. X
  890. X  if (!enable_update_display)
  891. X    return;
  892. X  if (redraw)
  893. X    {
  894. X      fprintf (fpout, "\n");
  895. X      for (r = 7; r >= 0; r--)
  896. X    {
  897. X      for (c = 0; c <= 7; c++)
  898. X        {
  899. X          l = locn (r, c);
  900. X          if (color[l] == neutral)
  901. X        fprintf (fpout, " -");
  902. X          else if (color[l] == white)
  903. X        fprintf (fpout, " %c", qxx[board[l]]);
  904. X          else
  905. X        fprintf (fpout, " %c", pxx[board[l]]);
  906. X        }
  907. X      fprintf (fpout, "\n");
  908. X    }
  909. X      fprintf (fpout, "\n");
  910. X    }
  911. X#endif /* CHESSTOOL */
  912. X#ifdef MSDOS
  913. X  f++;
  914. X  t++;
  915. X  isspec++;            /* shut up the compiler */
  916. X#endif /* MSDOS */
  917. X}
  918. X
  919. Xvoid
  920. XGetGame (void)
  921. X{
  922. X}
  923. X
  924. Xvoid
  925. XSaveGame (void)
  926. X{
  927. X}
  928. X
  929. Xvoid
  930. XListGame (void)
  931. X{
  932. X}
  933. X
  934. X
  935. X
  936. Xvoid
  937. XUndo (void)
  938. X
  939. X/*
  940. X * Undo the most recent half-move.
  941. X */
  942. X
  943. X{
  944. X  short f, t;
  945. X
  946. X  f = GameList[GameCnt].gmove >> 8;
  947. X  t = GameList[GameCnt].gmove & 0xFF;
  948. X  if (board[t] == king && distance (t, f) > 1)
  949. X    (void) castle (GameList[GameCnt].color, f, t, 2);
  950. X  else
  951. X    {
  952. X      /* Check for promotion: */
  953. X      if (GameList[GameCnt].flags & promote)
  954. X    {
  955. X      board[t] = pawn;
  956. X    }
  957. X      board[f] = board[t];
  958. X      color[f] = color[t];
  959. X      board[t] = GameList[GameCnt].piece;
  960. X      color[t] = GameList[GameCnt].color;
  961. X      if (color[t] != neutral)
  962. X    Mvboard[t]--;
  963. X      Mvboard[f]--;
  964. X    }
  965. X  if (GameList[GameCnt].flags & epmask)
  966. X    EnPassant (color[t], f, t, 2);
  967. X  if (TCflag)
  968. X    ++TimeControl.moves[color[f]];
  969. X  GameCnt--;
  970. X  computer = otherside[computer];
  971. X  opponent = otherside[opponent];
  972. X  flag.mate = false;
  973. X  Sdepth = 0;
  974. X  InitializeStats ();
  975. X}
  976. X
  977. Xvoid
  978. XShowMessage (char *s)
  979. X{
  980. X  fprintf (stderr, "%s\n", s);
  981. X}
  982. X
  983. Xvoid
  984. XShowSidetoMove (void)
  985. X{
  986. X}
  987. X
  988. Xvoid
  989. XPromptForMove (void)
  990. X{
  991. X#ifndef CHESSTOOL
  992. X  printz ("\nYour move is? ");
  993. X#endif /* CHESSTOOL */
  994. X}
  995. X
  996. X
  997. Xvoid
  998. XShowCurrentMove (short int pnt, short int f, short int t)
  999. X{
  1000. X#ifdef MSDOS
  1001. X  f++;
  1002. X  t++;
  1003. X  pnt++;            /* shut up the compiler */
  1004. X#endif /* MSDOS */
  1005. X}
  1006. X
  1007. Xvoid
  1008. XChangeAlphaWindow (void)
  1009. X{
  1010. X  printz ("window: ");
  1011. X}
  1012. X
  1013. Xvoid
  1014. XChangeBetaWindow (void)
  1015. X{
  1016. X  printz ("window: ");
  1017. X}
  1018. X
  1019. Xvoid
  1020. XGiveHint (void)
  1021. X{
  1022. X  algbr ((short) (hint >> 8), (short) (hint & 0xFF), false);
  1023. X  fprintf (stderr, "Hint: %s\n", mvstr[0]);
  1024. X}
  1025. X
  1026. Xvoid
  1027. XSelectLevel (void)
  1028. X{
  1029. X}
  1030. X
  1031. Xvoid
  1032. XChangeSearchDepth (void)
  1033. X{
  1034. X  printz ("depth= ");
  1035. X  scanz ("%hd", &MaxSearchDepth);
  1036. X}
  1037. X
  1038. Xvoid
  1039. XSetContempt (void)
  1040. X{
  1041. X  printz ("contempt= ");
  1042. X  scanz ("%hd", &contempt);
  1043. X}
  1044. X
  1045. Xvoid
  1046. XChangeXwindow (void)
  1047. X{
  1048. X  printz ("xwndw= ");
  1049. X  scanz ("%hd", &xwndw);
  1050. X}
  1051. X
  1052. Xvoid
  1053. XTestSpeed (void (*f) (short int side, short int ply))
  1054. X{
  1055. X  short i;
  1056. X  long cnt, rate, t1, t2;
  1057. X
  1058. X  t1 = time (0);
  1059. X  for (i = 0; i < 10000; i++)
  1060. X    {
  1061. X      f (opponent, 2);
  1062. X    }
  1063. X  t2 = time (0);
  1064. X  cnt = 10000L * (TrPnt[3] - TrPnt[2]);
  1065. X  rate = cnt / (t2 - t1);
  1066. X  printz ("Nodes= %ld Nodes/sec= %ld\n", cnt, rate);
  1067. X}
  1068. X
  1069. X
  1070. Xint
  1071. XGetNextMove (char *buffer)
  1072. X{
  1073. X  char current;
  1074. X
  1075. X  while (true)
  1076. X    {
  1077. X      while ((current = fgetc (fpin)) == ' ' || current == '\n') ;
  1078. X      if ((current != EOF) && (isdigit (current) || current == '-'))
  1079. X    {
  1080. X      while ((current = fgetc (fpin)) != ' ' && current != EOF) ;
  1081. X      if (current == EOF)
  1082. X        return 0;
  1083. X      else
  1084. X        continue;
  1085. X    }
  1086. X      if (current == EOF)
  1087. X    return (0);
  1088. X      while (current != ' ' && current != '\n' && current != EOF)
  1089. X    {
  1090. X      if (!(current == '-' || current == 'x' || current == 'X'))
  1091. X        {
  1092. X          *buffer++ = current;
  1093. X        }
  1094. X      current = fgetc (fpin);
  1095. X    }
  1096. X      *buffer = '\0';
  1097. X      return (1);
  1098. X    }
  1099. X}
  1100. X
  1101. Xvoid
  1102. XInputCommand (void)
  1103. X
  1104. X/*
  1105. X * Open the file of moves to analyse.  Go through the file move by move and
  1106. X * do the following for each move.  See what gnuchess would have done in that
  1107. X * position.  Record the move it would have made along with the score it
  1108. X * would have given and the search depth.  Take back its move. Force the move
  1109. X * that was actually made.  Keep track of statistics such as how many moves
  1110. X * agreed.
  1111. X */
  1112. X
  1113. X{
  1114. X  int i;
  1115. X  short ok, tmp;
  1116. X  int search_depth, max_minutes;
  1117. X  long cnt, rate, t1, t2;
  1118. X  unsigned short mv;
  1119. X  char s[80];
  1120. X  char infilename[255];
  1121. X  char outfilename[255];
  1122. X  char progfilename[255];
  1123. X  char inbuf[256];
  1124. X  int move_number = 1;
  1125. X  long start_time, end_time, elapsed_time;
  1126. X  int total_black_moves, total_white_moves;
  1127. X  int same_black_moves, same_white_moves;
  1128. X  float white_percent, black_percent;
  1129. X
  1130. X  /* Initialize necessary variables. */
  1131. X
  1132. X  flag.quit = false;
  1133. X  flag.beep = false;
  1134. X  player = opponent;
  1135. X  enable_update_display = 1;
  1136. X  ft = 0;
  1137. X  Book = NULL;
  1138. X  total_black_moves = 0;
  1139. X  total_white_moves = 0;
  1140. X  same_black_moves = 0;
  1141. X  same_white_moves = 0;
  1142. X
  1143. X#ifdef BACKGROUND_ANALYSIS
  1144. X
  1145. X  /*
  1146. X   * Set the in files to standard ones for analysis if background
  1147. X   * processing selected.
  1148. X   */
  1149. X
  1150. X  strcpy (infilename, IN_FILE);
  1151. X  strcpy (outfilename, OUT_FILE);
  1152. X  strcpy (progfilename, PROG_FILE);
  1153. X  fpout = fopen (outfilename, "w");
  1154. X  if (fpout == NULL)
  1155. X    {
  1156. X      fprintf (fpout, "This file does not exist : %s\n", outfilename);
  1157. X      flag.quit = 1;
  1158. X      return;
  1159. X    }
  1160. X  MaxSearchDepth = MAX_DEPTH;
  1161. X  TCminutes = MAX_TIME;
  1162. X
  1163. X#else
  1164. X
  1165. X  /* Request information on where the file is and the depth an time. */
  1166. X
  1167. X  fpout = stderr;
  1168. X  fprintf (fpout, "Input the file with the algebraic moves of the game.\n");
  1169. X  gets (infilename);
  1170. X  fprintf (fpout, "\n");
  1171. X  do
  1172. X    {
  1173. X      fprintf (fpout, "Input the search depth you want to use.  (1 to 29)\n");
  1174. X      gets (inbuf);
  1175. X      search_depth = atoi (inbuf);
  1176. X  } while (search_depth < 1 || search_depth > 29);
  1177. X  MaxSearchDepth = search_depth;
  1178. X
  1179. X  fprintf (fpout, "\n");
  1180. X  do
  1181. X    {
  1182. X      fprintf (fpout, "Input the maximum number of minutes per move you want to use.\n");
  1183. X      gets (inbuf);
  1184. X      max_minutes = atoi (inbuf);
  1185. X  } while (max_minutes < 1);
  1186. X  printf ("%d %d \n", search_depth, max_minutes);
  1187. X  TCminutes = max_minutes;
  1188. X
  1189. X  fprintf (fpout, "\n\n");
  1190. X
  1191. X#endif
  1192. X
  1193. X  fpin = fopen (infilename, "r");
  1194. X  if (fpin == NULL)
  1195. X    {
  1196. X      fprintf (fpout, "This file does not exist : %s\n", infilename);
  1197. X      flag.quit = 1;
  1198. X      return;
  1199. X    }
  1200. X  /* lets find out about this file */
  1201. X  fgets (InBuf, 256, fpin);
  1202. X  InFileType = OTHER;
  1203. X  if (!strncmp (InBuf, "xboard", 6))
  1204. X    {
  1205. X      InFileType = XBOARD;
  1206. X      fgets (InBuf, 256, fpin);
  1207. X      fgets (InBuf, 256, fpin);
  1208. X    }
  1209. X  else if (!strncmp (InBuf, "gnuchess", 6))
  1210. X    {
  1211. X      InFileType = GNUCHESS;
  1212. X      fgets (InBuf, 256, fpin);
  1213. X    }
  1214. X  else
  1215. X    rewind (fpin);
  1216. X  TCmoves = 1;
  1217. X  TCflag = (TCmoves > 1);
  1218. X  OperatorTime = 0;
  1219. X  SetTimeControl ();
  1220. X
  1221. X  fpout = stdout;
  1222. X
  1223. X  fprintf (fpout, "Move White Black      Score Depth     Best Line\n");
  1224. X  fprintf (fpout, "------------------------------------------------------------------\n");
  1225. X
  1226. X#ifdef BACKGROUND_ANALYSIS
  1227. X
  1228. X  /*
  1229. X   * Update progress in the progress file if this is running in the
  1230. X   * background.
  1231. X   */
  1232. X
  1233. X  fpprog = fopen (progfilename, "w");
  1234. X  fprintf (fpprog, "Done with move #%d.\n", move_number - 1);
  1235. X  fclose (fpprog);
  1236. X
  1237. X#endif
  1238. X
  1239. X  time (&start_time);
  1240. X  while (1)
  1241. X    {
  1242. X      opponent = black;
  1243. X      computer = white;
  1244. X      player = computer;
  1245. X      white_moving = 1;
  1246. X      if (!GetNextMove (s))
  1247. X    {
  1248. X      flag.quit = 1;
  1249. X      break;
  1250. X    }
  1251. X      if (!strcmp (s, "Black") || !strcmp (s, "White") || !strcmp (s, "draw"))
  1252. X    break;
  1253. X      flag.force = 0;
  1254. X      SelectMove (computer, 1);
  1255. X      Undo ();
  1256. X      flag.force = 1;
  1257. X      opponent = white;
  1258. X      computer = black;
  1259. X      player = opponent;
  1260. X      ok = VerifyMove (s, 0, &mv);
  1261. X      if (!ok)
  1262. X    {
  1263. X      fprintf (fpout, "\nBad move.  %s  Board position is: \n", s);
  1264. X      UpdateDisplay (0, 0, 1, 0);
  1265. X      flag.quit = 1;
  1266. X      break;
  1267. X    }
  1268. X      else
  1269. X    {
  1270. X      char ch, x[80];
  1271. X      strcpy (white_actual_move, s);
  1272. X      strcpy (x, white_actual_move);
  1273. X      if (strcmp (white_actual_move, white_suggest_move))
  1274. X        strcat (x, "*");
  1275. X      fprintf (fpout, "%3d   %-9s      %5d%5d   ", move_number, x, white_score, current_depth);
  1276. X      for (i = 1; MV[i] > 0; i++)
  1277. X        {
  1278. X          algbr ((short) (MV[i] >> 8), (short) (MV[i] & 0xFF), false);
  1279. X          printf ("%5s ", mvstr[0]);
  1280. X        }
  1281. X      printf ("\n");
  1282. X      fflush (fpout);
  1283. X      move_number++;
  1284. X      total_white_moves++;
  1285. X      if (!strcmp (white_actual_move, white_suggest_move))
  1286. X        same_white_moves++;
  1287. X      Sdepth = 0;
  1288. X      ft = 0;
  1289. X    }
  1290. X      player = computer;
  1291. X      white_moving = 0;
  1292. X      if (!GetNextMove (s))
  1293. X    {
  1294. X      flag.quit = 1;
  1295. X      break;
  1296. X    }
  1297. X      if (!strcmp (s, "Black") || !strcmp (s, "White") || !strcmp (s, "draw"))
  1298. X    break;
  1299. X      flag.force = 0;
  1300. X      SelectMove (computer, 1);
  1301. X      Undo ();
  1302. X      flag.force = 1;
  1303. X      opponent = black;
  1304. X      computer = white;
  1305. X      player = opponent;
  1306. X      ok = VerifyMove (s, 0, &mv);
  1307. X      if (!ok)
  1308. X    {
  1309. X      fprintf (fpout, "\nBad move.  %s  Board position is: \n", s);
  1310. X      UpdateDisplay (0, 0, 1, 0);
  1311. X      flag.quit = 1;
  1312. X      break;
  1313. X    }
  1314. X      else
  1315. X    {
  1316. X      char x[8];
  1317. X      strcpy (black_actual_move, s);
  1318. X      strcpy (x, black_actual_move);
  1319. X      if (strcmp (black_actual_move, black_suggest_move))
  1320. X        strcat (x, "*");
  1321. X      fprintf (fpout, "            %-9s%5d%5d   ", x, black_score, current_depth);
  1322. X      for (i = 1; MV[i] > 0; i++)
  1323. X        {
  1324. X          algbr ((short) (MV[i] >> 8), (short) (MV[i] & 0xFF), false);
  1325. X          printf ("%5s ", mvstr[0]);
  1326. X        }
  1327. X      printf ("\n");
  1328. X      fflush (fpout);
  1329. X
  1330. X#ifdef BACKGROUND_ANALYSIS
  1331. X
  1332. X      /*
  1333. X           * Update progress in the progress file if this is running in the
  1334. X           * background.
  1335. X           */
  1336. X
  1337. X      fpprog = fopen (progfilename, "w");
  1338. X      fprintf (fpprog, "Done with move #%d.\n", move_number - 1);
  1339. X      fclose (fpprog);
  1340. X#else
  1341. X
  1342. X      /*
  1343. X           * fprintf(stderr, "Done with move #%d.\n", move_number-1);
  1344. X           */
  1345. X
  1346. X#endif
  1347. X
  1348. X      total_black_moves++;
  1349. X      if (!strcmp (black_actual_move, black_suggest_move))
  1350. X        same_black_moves++;
  1351. X      Sdepth = 0;
  1352. X      ft = 0;
  1353. X    }
  1354. X    }
  1355. X
  1356. X  white_percent = ((float) same_white_moves) * 100 / (float) total_white_moves;
  1357. X  black_percent = ((float) same_black_moves) * 100 / (float) total_black_moves;
  1358. X  fprintf (fpout, "\n           White's percentage was %5.2f%%.     Black's percentage was %5.2f%%.\n", white_percent, black_percent);
  1359. X  time (&end_time);
  1360. X  elapsed_time = end_time - start_time;
  1361. X  fprintf (fpout, "\n           Elapsed time was %d seconds.\n", elapsed_time);
  1362. X  fclose (fpin);
  1363. X  fclose (fpout);
  1364. X  exit (0);
  1365. X}
  1366. END_OF_FILE
  1367. if test 20399 -ne `wc -c <'src/gnuan.c'`; then
  1368.     echo shar: \"'src/gnuan.c'\" unpacked with wrong size!
  1369. fi
  1370. # end of 'src/gnuan.c'
  1371. fi
  1372. if test -f 'src/init.c' -a "${1}" != "-c" ; then 
  1373.   echo shar: Will not clobber existing file \"'src/init.c'\"
  1374. else
  1375. echo shar: Extracting \"'src/init.c'\" \(11648 characters\)
  1376. sed "s/^X//" >'src/init.c' <<'END_OF_FILE'
  1377. X/*
  1378. X * init.c - C source for GNU CHESS
  1379. X *
  1380. X * Copyright (c) 1988,1989,1990 John Stanback
  1381. X * Copyright (c) 1992 Free Software Foundation
  1382. X *
  1383. X * This file is part of GNU CHESS.
  1384. X *
  1385. X * GNU Chess is free software; you can redistribute it and/or modify
  1386. X * it under the terms of the GNU General Public License as published by
  1387. X * the Free Software Foundation; either version 2, or (at your option)
  1388. X * any later version.
  1389. X *
  1390. X * GNU Chess is distributed in the hope that it will be useful,
  1391. X * but WITHOUT ANY WARRANTY; without even the implied warranty of
  1392. X * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  1393. X * GNU General Public License for more details.
  1394. X *
  1395. X * You should have received a copy of the GNU General Public License
  1396. X * along with GNU Chess; see the file COPYING.  If not, write to
  1397. X * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  1398. X */
  1399. X#include "gnuchess.h"
  1400. X
  1401. X/* .... MOVE GENERATION VARIABLES AND INITIALIZATIONS .... */
  1402. X
  1403. X
  1404. Xshort distdata[64][64], taxidata[64][64];
  1405. X
  1406. X/* put moves to the center first */
  1407. Xvoid
  1408. XInitialize_killt (void)
  1409. X{
  1410. X  register unsigned short f, t, s;
  1411. X  register short d;
  1412. X  for (f = 64; f--;)
  1413. X    for (t = 64; t--;)
  1414. X      {
  1415. X    d = taxidata[f][0x1b];
  1416. X    if (taxidata[f][0x1c] < d)
  1417. X      d = taxidata[f][0x1c];
  1418. X    if (taxidata[f][0x23] < d)
  1419. X      d = taxidata[f][0x23];
  1420. X    if (taxidata[f][0x24] < d)
  1421. X      d = taxidata[f][0x24];
  1422. X    s = d;
  1423. X    d = taxidata[t][0x1b];
  1424. X    if (taxidata[t][0x1c] < d)
  1425. X      d = taxidata[t][0x1c];
  1426. X    if (taxidata[t][0x23] < d)
  1427. X      d = taxidata[t][0x23];
  1428. X    if (taxidata[t][0x24] < d)
  1429. X      d = taxidata[t][0x24];
  1430. X    s -= d;
  1431. X    killt[(f << 8) | t] = s;
  1432. X    killt[(f << 8) | t | 0x80] = s;
  1433. X      }
  1434. X}
  1435. X
  1436. Xvoid
  1437. XInitialize_dist (void)
  1438. X{
  1439. X  register short a, b, d, di;
  1440. X
  1441. X  for (a = 0; a < 64; a++)
  1442. X    for (b = 0; b < 64; b++)
  1443. X      {
  1444. X    d = abs (column (a) - column (b));
  1445. X    di = abs (row (a) - row (b));
  1446. X    taxidata[a][b] = d + di;
  1447. X    distdata[a][b] = (d > di ? d : di);
  1448. X      }
  1449. X  Initialize_killt ();
  1450. X}
  1451. X
  1452. Xconst short Stboard[64] =
  1453. X{rook, knight, bishop, queen, king, bishop, knight, rook,
  1454. X pawn, pawn, pawn, pawn, pawn, pawn, pawn, pawn,
  1455. X 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  1456. X 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  1457. X pawn, pawn, pawn, pawn, pawn, pawn, pawn, pawn,
  1458. X rook, knight, bishop, queen, king, bishop, knight, rook};
  1459. Xconst short Stcolor[64] =
  1460. X{white, white, white, white, white, white, white, white,
  1461. X white, white, white, white, white, white, white, white,
  1462. X neutral, neutral, neutral, neutral, neutral, neutral, neutral, neutral,
  1463. X neutral, neutral, neutral, neutral, neutral, neutral, neutral, neutral,
  1464. X neutral, neutral, neutral, neutral, neutral, neutral, neutral, neutral,
  1465. X neutral, neutral, neutral, neutral, neutral, neutral, neutral, neutral,
  1466. X black, black, black, black, black, black, black, black,
  1467. X black, black, black, black, black, black, black, black};
  1468. Xshort board[64], color[64];
  1469. X
  1470. X/* given epsquare, from where can a pawn be taken? */
  1471. Xconst short epmove1[64] =
  1472. X{0, 1, 2, 3, 4, 5, 6, 7,
  1473. X 8, 9, 10, 11, 12, 13, 14, 15,
  1474. X 16, 24, 25, 26, 27, 28, 29, 30,
  1475. X 24, 25, 26, 27, 28, 29, 30, 31,
  1476. X 32, 33, 34, 35, 36, 37, 38, 39,
  1477. X 40, 32, 33, 34, 35, 36, 37, 38,
  1478. X 48, 49, 50, 51, 52, 53, 54, 55,
  1479. X 56, 57, 58, 59, 60, 61, 62, 63};
  1480. Xconst short epmove2[64] =
  1481. X{0, 1, 2, 3, 4, 5, 6, 7,
  1482. X 8, 9, 10, 11, 12, 13, 14, 15,
  1483. X 25, 26, 27, 28, 29, 30, 31, 23,
  1484. X 24, 25, 26, 27, 28, 29, 30, 31,
  1485. X 32, 33, 34, 35, 36, 37, 38, 39,
  1486. X 33, 34, 35, 36, 37, 38, 39, 47,
  1487. X 48, 49, 50, 51, 52, 53, 54, 55,
  1488. X 56, 57, 58, 59, 60, 61, 62, 63};
  1489. X
  1490. X
  1491. X/*
  1492. X * nextpos[piece][from-square] , nextdir[piece][from-square] gives vector of
  1493. X * positions reachable from from-square in ppos with piece such that the
  1494. X * sequence    ppos = nextpos[piece][from-square]; pdir =
  1495. X * nextdir[piece][from-square]; u = ppos[sq]; do { u = ppos[u]; if(color[u]
  1496. X * != neutral) u = pdir[u]; } while (sq != u); will generate the sequence of
  1497. X * all squares reachable from sq.
  1498. X *
  1499. X * If the path is blocked u = pdir[sq] will generate the continuation of the
  1500. X * sequence in other directions.
  1501. X */
  1502. X
  1503. Xunsigned char nextpos[8][64][64];
  1504. Xunsigned char nextdir[8][64][64];
  1505. X
  1506. X/*
  1507. X * ptype is used to separate white and black pawns, like this; ptyp =
  1508. X * ptype[side][piece] piece can be used directly in nextpos/nextdir when
  1509. X * generating moves for pieces that are not black pawns.
  1510. X */
  1511. Xconst short ptype[2][8] =
  1512. X{
  1513. X  no_piece, pawn, knight, bishop, rook, queen, king, no_piece,
  1514. X  no_piece, bpawn, knight, bishop, rook, queen, king, no_piece};
  1515. X
  1516. X/* data used to generate nextpos/nextdir */
  1517. Xstatic const short direc[8][8] =
  1518. X{
  1519. X  0, 0, 0, 0, 0, 0, 0, 0,
  1520. X  10, 9, 11, 0, 0, 0, 0, 0,
  1521. X  8, -8, 12, -12, 19, -19, 21, -21,
  1522. X  9, 11, -9, -11, 0, 0, 0, 0,
  1523. X  1, 10, -1, -10, 0, 0, 0, 0,
  1524. X  1, 10, -1, -10, 9, 11, -9, -11,
  1525. X  1, 10, -1, -10, 9, 11, -9, -11,
  1526. X  -10, -9, -11, 0, 0, 0, 0, 0};
  1527. Xstatic const short max_steps[8] =
  1528. X{0, 2, 1, 7, 7, 7, 1, 2};
  1529. Xstatic const short nunmap[120] =
  1530. X{
  1531. X  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  1532. X  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  1533. X  -1, 0, 1, 2, 3, 4, 5, 6, 7, -1,
  1534. X  -1, 8, 9, 10, 11, 12, 13, 14, 15, -1,
  1535. X  -1, 16, 17, 18, 19, 20, 21, 22, 23, -1,
  1536. X  -1, 24, 25, 26, 27, 28, 29, 30, 31, -1,
  1537. X  -1, 32, 33, 34, 35, 36, 37, 38, 39, -1,
  1538. X  -1, 40, 41, 42, 43, 44, 45, 46, 47, -1,
  1539. X  -1, 48, 49, 50, 51, 52, 53, 54, 55, -1,
  1540. X  -1, 56, 57, 58, 59, 60, 61, 62, 63, -1,
  1541. X  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
  1542. X  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1};
  1543. X
  1544. Xint InitFlag = false;
  1545. Xvoid
  1546. XInitialize_moves (void)
  1547. X
  1548. X/*
  1549. X * This procedure pre-calculates all moves for every piece from every square.
  1550. X * This data is stored in nextpos/nextdir and used later in the move
  1551. X * generation routines.
  1552. X */
  1553. X
  1554. X{
  1555. X  short ptyp, po, p0, d, di, s, delta;
  1556. X  unsigned char *ppos, *pdir;
  1557. X  short dest[8][8];
  1558. X  short steps[8];
  1559. X  short sorted[8];
  1560. X
  1561. X  for (ptyp = 0; ptyp < 8; ptyp++)
  1562. X    for (po = 0; po < 64; po++)
  1563. X      for (p0 = 0; p0 < 64; p0++)
  1564. X    {
  1565. X      nextpos[ptyp][po][p0] = (unsigned char) po;
  1566. X      nextdir[ptyp][po][p0] = (unsigned char) po;
  1567. X    }
  1568. X  for (ptyp = 1; ptyp < 8; ptyp++)
  1569. X    for (po = 21; po < 99; po++)
  1570. X      if (nunmap[po] >= 0)
  1571. X    {
  1572. X      ppos = nextpos[ptyp][nunmap[po]];
  1573. X      pdir = nextdir[ptyp][nunmap[po]];
  1574. X      /* dest is a function of direction and steps */
  1575. X      for (d = 0; d < 8; d++)
  1576. X        {
  1577. X          dest[d][0] = nunmap[po];
  1578. X          delta = direc[ptyp][d];
  1579. X          if (delta != 0)
  1580. X        {
  1581. X          p0 = po;
  1582. X          for (s = 0; s < max_steps[ptyp]; s++)
  1583. X            {
  1584. X              p0 = p0 + delta;
  1585. X
  1586. X              /*
  1587. X               * break if (off board) or (pawns only move two
  1588. X               * steps from home square)
  1589. X               */
  1590. X              if ((nunmap[p0] < 0) || (((ptyp == pawn) || (ptyp == bpawn))
  1591. X                           && ((s > 0) && ((d > 0) || (Stboard[nunmap[po]] != pawn)))))
  1592. X            break;
  1593. X              else
  1594. X            dest[d][s] = nunmap[p0];
  1595. X            }
  1596. X        }
  1597. X          else
  1598. X        s = 0;
  1599. X
  1600. X          /*
  1601. X           * sort dest in number of steps order currently no sort
  1602. X           * is done due to compability with the move generation
  1603. X           * order in old gnu chess
  1604. X           */
  1605. X          steps[d] = s;
  1606. X          for (di = d; s > 0 && di > 0; di--)
  1607. X        if (steps[sorted[di - 1]] == 0)    /* should be: < s */
  1608. X          sorted[di] = sorted[di - 1];
  1609. X        else
  1610. X          break;
  1611. X          sorted[di] = d;
  1612. X        }
  1613. X
  1614. X      /*
  1615. X       * update nextpos/nextdir, pawns have two threads (capture
  1616. X       * and no capture)
  1617. X       */
  1618. X      p0 = nunmap[po];
  1619. X      if (ptyp == pawn || ptyp == bpawn)
  1620. X        {
  1621. X          for (s = 0; s < steps[0]; s++)
  1622. X        {
  1623. X          ppos[p0] = (unsigned char) dest[0][s];
  1624. X          p0 = dest[0][s];
  1625. X        }
  1626. X          p0 = nunmap[po];
  1627. X          for (d = 1; d < 3; d++)
  1628. X        {
  1629. X          pdir[p0] = (unsigned char) dest[d][0];
  1630. X          p0 = dest[d][0];
  1631. X        }
  1632. X        }
  1633. X      else
  1634. X        {
  1635. X          pdir[p0] = (unsigned char) dest[sorted[0]][0];
  1636. X          for (d = 0; d < 8; d++)
  1637. X        for (s = 0; s < steps[sorted[d]]; s++)
  1638. X          {
  1639. X            ppos[p0] = (unsigned char) dest[sorted[d]][s];
  1640. X            p0 = dest[sorted[d]][s];
  1641. X            if (d < 7)
  1642. X              pdir[p0] = (unsigned char) dest[sorted[d + 1]][0];
  1643. X
  1644. X            /*
  1645. X             * else is already initialized
  1646. X             */
  1647. X          }
  1648. X        }
  1649. X    }
  1650. X}
  1651. X
  1652. Xvoid
  1653. XNewGame (void)
  1654. X
  1655. X/*
  1656. X * Reset the board and other variables to start a new game.
  1657. X */
  1658. X
  1659. X{
  1660. X  short l, c, p;
  1661. X
  1662. X  stage = stage2 = -1;        /* the game is not yet started */
  1663. X  flag.mate = flag.post = flag.quit = flag.reverse = flag.bothsides = false;
  1664. X  flag.force = false;
  1665. X  flag.coords = true;
  1666. X  flag.hash = flag.easy = flag.beep = flag.rcptr = true;
  1667. X#if defined(MSDOS) && !defined(SEVENBIT)
  1668. X  flag.rv = false;
  1669. X#else
  1670. X  flag.stars = false;
  1671. X  flag.rv = true;
  1672. X  flag.material = true;
  1673. X  flag.shade = false;
  1674. X  flag.musttimeout = false;
  1675. X
  1676. X#endif /* MSDOS && !SEVENBIT */
  1677. X
  1678. X  NodeCnt = et0 = epsquare = 0;
  1679. X  dither = 0;
  1680. X  XCmore = 0;
  1681. X  WAwindow = WAWNDW;
  1682. X  WBwindow = WBWNDW;
  1683. X  BAwindow = BAWNDW;
  1684. X  BBwindow = BBWNDW;
  1685. X  xwndw = BXWNDW;
  1686. X  if (!MaxSearchDepth)
  1687. X    MaxSearchDepth = MAXDEPTH - 1;
  1688. X  contempt = 0;
  1689. X  GameCnt = 0;
  1690. X  Game50 = 1;
  1691. X  hint = 0x0C14;
  1692. X  ZeroRPT ();
  1693. X  Developed[white] = Developed[black] = false;
  1694. X  castld[white] = castld[black] = false;
  1695. X  PawnThreat[0] = CptrFlag[0] = false;
  1696. X  Pscore[0] = 12000;
  1697. X  Tscore[0] = 12000;
  1698. X  opponent = white;
  1699. X  computer = black;
  1700. X  for (l = 0; l < TREE; l++)
  1701. X    Tree[l].f = Tree[l].t = 0;
  1702. X#if ttblsz
  1703. X  ZeroTTable ();
  1704. X#endif /* ttblsz */
  1705. X  srand ((unsigned int) 1);
  1706. X  if (!InitFlag)
  1707. X    {
  1708. X      for (c = white; c <= black; c++)
  1709. X    for (p = pawn; p <= king; p++)
  1710. X      for (l = 0; l < 64; l++)
  1711. X        {
  1712. X          hashcode[c][p][l].key = (((unsigned long) urand ()));
  1713. X          hashcode[c][p][l].key += (((unsigned long) urand ()) << 16);
  1714. X          hashcode[c][p][l].bd = (((unsigned long) urand ()));
  1715. X          hashcode[c][p][l].bd += (((unsigned long) urand ()) << 16);
  1716. X#ifdef LONG64
  1717. X          hashcode[c][p][l].key += (((unsigned long) urand ()) << 32);
  1718. X          hashcode[c][p][l].key += (((unsigned long) urand ()) << 48);
  1719. X          hashcode[c][p][l].bd += (((unsigned long) urand ()) << 32);
  1720. X          hashcode[c][p][l].bd += (((unsigned long) urand ()) << 48);
  1721. X#endif
  1722. X        }
  1723. X    }
  1724. X  for (l = 0; l < 64; l++)
  1725. X    {
  1726. X      board[l] = Stboard[l];
  1727. X      color[l] = Stcolor[l];
  1728. X      Mvboard[l] = 0;
  1729. X    }
  1730. X  ClrScreen ();
  1731. X  InitializeStats ();
  1732. X  time0 = time ((long *) 0);
  1733. X  ElapsedTime (1);
  1734. X  flag.regularstart = true;
  1735. X  Book = BOOKFAIL;
  1736. X  if (!InitFlag)
  1737. X    {
  1738. X      if (TCflag)
  1739. X    SetTimeControl ();
  1740. X      else if (Level == 0)
  1741. X    SelectLevel ();
  1742. X      UpdateDisplay (0, 0, 1, 0);
  1743. X      GetOpenings ();
  1744. X      InitFlag = true;
  1745. X    }
  1746. X  hashbd = hashkey = 0;
  1747. X}
  1748. Xvoid
  1749. XInitConst (char *lang)
  1750. X{
  1751. X  FILE *constfile;
  1752. X  char s[256];
  1753. X  char sl[5];
  1754. X  int len, entry;
  1755. X  char *r, *p, *q;
  1756. X  constfile = fopen (LANGFILE, "r");
  1757. X  if (!constfile)
  1758. X    {
  1759. X      printf ("NO LANGFILE\n");
  1760. X      exit ();
  1761. X    }
  1762. X  while (fgets (s, sizeof (s), constfile))
  1763. X    {
  1764. X      if (s[0] == '!')
  1765. X    continue;
  1766. X      len = strlen (s);
  1767. X      for (q = &s[len]; q > &s[8]; q--)
  1768. X    if (*q == '}')
  1769. X      break;
  1770. X      if (q == &s[8])
  1771. X    {
  1772. X      printf ("{ error in cinstfile\n");
  1773. X      exit ();
  1774. X    }
  1775. X      *q = '\0';
  1776. X      if (s[3] != ':' || s[7] != ':' || s[8] != '{')
  1777. X    {
  1778. X      printf ("Langfile format error %s\n", s);
  1779. X      exit ();
  1780. X    }
  1781. X      s[3] = s[7] = '\0';
  1782. X      if (lang == NULL)
  1783. X    {
  1784. X      lang = sl;
  1785. X      strcpy (sl, &s[4]);
  1786. X    }
  1787. X      if (strcmp (&s[4], lang))
  1788. X    continue;
  1789. X      entry = atoi (s);
  1790. X      if (entry < 0 || entry >= CPSIZE)
  1791. X    {
  1792. X      printf ("Langfile number error\n");
  1793. X      exit ();
  1794. X    }
  1795. X      for (q = p = &s[9]; *p; p++)
  1796. X    {
  1797. X      if (*p != '\\')
  1798. X        {
  1799. X          *q++ = *p;
  1800. X        }
  1801. X      else if (*(p + 1) == 'n')
  1802. X        {
  1803. X          *q++ = '\n';
  1804. X          p++;
  1805. X        }
  1806. X    }
  1807. X      *q = '\0';
  1808. X      if (entry < 0 || entry > 255)
  1809. X    {
  1810. X      printf ("Langfile error %d\n", entry);
  1811. X      exit (0);
  1812. X    }
  1813. X      CP[entry] = (char *) malloc ((unsigned) strlen (&s[9]) + 1);
  1814. X      if (CP[entry] == NULL)
  1815. X    {
  1816. X      perror ("malloc");
  1817. X      exit (0);
  1818. X    }
  1819. X      strcpy (CP[entry], &s[9]);
  1820. X
  1821. X    }
  1822. X  fclose (constfile);
  1823. X}
  1824. X
  1825. X#ifdef ttblsz
  1826. Xvoid
  1827. XInitialize_ttable ()
  1828. X{
  1829. X  if (rehash < 0)
  1830. X    rehash = MAXrehash - 1;
  1831. X}
  1832. X
  1833. X#endif /* ttblsz */
  1834. END_OF_FILE
  1835. if test 11648 -ne `wc -c <'src/init.c'`; then
  1836.     echo shar: \"'src/init.c'\" unpacked with wrong size!
  1837. fi
  1838. # end of 'src/init.c'
  1839. fi
  1840. echo shar: End of archive 8 \(of 12\).
  1841. cp /dev/null ark8isdone
  1842. MISSING=""
  1843. for I in 1 2 3 4 5 6 7 8 9 10 11 12 ; do
  1844.     if test ! -f ark${I}isdone ; then
  1845.     MISSING="${MISSING} ${I}"
  1846.     fi
  1847. done
  1848. if test "${MISSING}" = "" ; then
  1849.     echo You have unpacked all 12 archives.
  1850.     rm -f ark[1-9]isdone ark[1-9][0-9]isdone
  1851.     echo Building book file.
  1852.     cat misc/book.xaa misc/book.xab > misc/gnuchess.nunn.book
  1853.     rm misc/book.xaa misc/book.xab
  1854. else
  1855.     echo You still need to unpack the following archives:
  1856.     echo "        " ${MISSING}
  1857. fi
  1858. ##  End of shell archive.
  1859. exit 0
  1860.