home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 3 / 3379 < prev    next >
Encoding:
Internet Message Format  |  1991-05-21  |  50.5 KB
  1. From: ml@brumuc.muc.sub.org (Marc Laukien)
  2. Newsgroups: alt.sources
  3. Subject: UnixChess01/10
  4. Message-ID: <1991May20.003042.6166@brumuc.muc.sub.org>
  5. Date: 20 May 91 00:30:42 GMT
  6.  
  7. Submitted-by: ml@brumuc.muc.sub.org
  8. Archive-name: UnixChess/part01
  9.  
  10. This is UnixChess V2.7, a chess program designed for bulletin board
  11. systems. It's tested with Interactive Unix 2.2.
  12.  
  13. The program has the following features:
  14.  
  15. o    Large opening library
  16. o    Training mode with variable levels, 'take back', setup etc.
  17. o    Tournament mode versus the computer
  18. o    Tournament mode versus other players
  19. o    Highscoretable for the tournament games
  20.  
  21. Unfortunately, I've only provided a german manual. It would be
  22. great, if someone who speaks english and german well, could translate
  23. and post it. However, the program itself, as well as the installation
  24. instructions, are provided in english and german.
  25.  
  26. If you have any problems to install it, write an email to
  27. 'ml@brumuc.muc.sub.org'.
  28.  
  29. ---- Cut Here and feed the following to sh ----
  30. #!/bin/sh
  31. # This is UnixChess, a shell archive (produced by shar 3.49)
  32. # To extract the files from this archive, save it to a file, remove
  33. # everything above the "!/bin/sh" line above, and type "sh file_name".
  34. #
  35. # made 05/20/1991 00:05 UTC by ml@brumuc.muc.sub.org
  36. # Source directory /usr2/games/xchess/XChess_V2.7
  37. #
  38. # existing files will NOT be overwritten unless -c is specified
  39. #
  40. # This is part 1 of a multipart archive                                    
  41. # do not concatenate these parts, unpack them in order with /bin/sh        
  42. #
  43. # This shar contains:
  44. # length  mode       name
  45. # ------ ---------- ------------------------------------------
  46. #    808 -rw-r--r-- README.eng
  47. #    651 -rw-r--r-- README.ger
  48. #   5280 -rw-r--r-- ch/value.c
  49. #   7880 -rw-r--r-- ch/main.c
  50. #   4354 -rw-r--r-- ch/move.c
  51. #   7250 -rw-r--r-- ch/comp.c
  52. #   7922 -rw-r--r-- ch/utility.c
  53. #   3106 -rw-r--r-- ch/threat.c
  54. #   4881 -rw-r--r-- ch/init.c
  55. #   7783 -rw-r--r-- ch/list.c
  56. #   5629 -rw-r--r-- ch/archiv.c
  57. #   7762 -rw-r--r-- ch/open.c
  58. #   2027 -rw-r--r-- ch/stat.c
  59. #   3355 -rw-r--r-- ad/main.c
  60. #   4435 -rw-r--r-- ad/init.c
  61. #   4819 -rw-r--r-- ad/utility.c
  62. #    752 -rw-r--r-- ad/monitor.c
  63. #   6749 -rw-r--r-- ad/window.c
  64. #   3257 -rw-r--r-- ad/move.c
  65. #   2103 -rw-r--r-- ad/interrupt.c
  66. #   2094 -rw-r--r-- ad/load.c
  67. #   3404 -rw-r--r-- ad/menu.c
  68. #   2071 -rw-r--r-- ad/lock.c
  69. #   7463 -rw-r--r-- ad/admin.c
  70. #   5856 -rw-r--r-- ad/screen.c
  71. #   1569 -rw-r--r-- ad/id.c
  72. #   5003 -rw-r--r-- ad/score.c
  73. #   2942 -rw-r--r-- ad/training.c
  74. #   4036 -rw-r--r-- ad/tour_user.c
  75. #   3534 -rw-r--r-- ad/tour_comp.c
  76. #   4458 -rw-r--r-- ad/expire.c
  77. #   3935 -rw-r--r-- ad/setup.c
  78. #   1141 -rw-r--r-- br/break.c
  79. #   6012 -rw-r--r-- ad/ad.h
  80. #   6139 -rw-r--r-- ch/ch.h
  81. #    557 -rw-r--r-- ch/ph.h
  82. #    277 -rw-r--r-- ad/patchlevel.h
  83. #   4484 -rw-r--r-- ad/lex.l
  84. #    277 -rw-r--r-- ad/patchlevel.h
  85. #    636 -rw-r--r-- op/op.albinsgegam
  86. #  24557 -rw-r--r-- op/op.aljechin
  87. #    880 -rw-r--r-- op/op.b2b4
  88. #  13307 -rw-r--r-- op/op.benoni
  89. #    687 -rw-r--r-- op/op.bird
  90. #    559 -rw-r--r-- op/op.budapestgam
  91. #   2227 -rw-r--r-- op/op.caro-kann
  92. #    659 -rw-r--r-- op/op.damenbaspie
  93. #   2491 -rw-r--r-- op/op.damengam
  94. #   1445 -rw-r--r-- op/op.damenind
  95. #    582 -rw-r--r-- op/op.dreispring
  96. #  35579 -rw-r--r-- op/op.englisch
  97. #    887 -rw-r--r-- op/op.evansgam
  98. #  24668 -rw-r--r-- op/op.franz
  99. #  23156 -rw-r--r-- op/op.gruenfeld
  100. #    666 -rw-r--r-- op/op.holland
  101. #    533 -rw-r--r-- op/op.indisch
  102. #   4496 -rw-r--r-- op/op.italienisch
  103. #    596 -rw-r--r-- op/op.katalanisch
  104. #   9399 -rw-r--r-- op/op.koenigsgam
  105. #   1618 -rw-r--r-- op/op.koenigsind
  106. #   1386 -rw-r--r-- op/op.laeufer
  107. #   1590 -rw-r--r-- op/op.nimzowitsch
  108. #    635 -rw-r--r-- op/op.nordgam
  109. #   2692 -rw-r--r-- op/op.philidor
  110. #    616 -rw-r--r-- op/op.ponziani
  111. #  11254 -rw-r--r-- op/op.reti
  112. #   1536 -rw-r--r-- op/op.russisch
  113. #    823 -rw-r--r-- op/op.schottisch
  114. #  71561 -rw-r--r-- op/op.sizilian
  115. #    935 -rw-r--r-- op/op.skandinav
  116. #   4330 -rw-r--r-- op/op.spanisch
  117. #    913 -rw-r--r-- op/op.ufimzew
  118. #    626 -rw-r--r-- op/op.ungarische
  119. #    594 -rw-r--r-- op/op.unregel
  120. #   2030 -rw-r--r-- op/op.vierspring
  121. #   1690 -rw-r--r-- op/op.wiener
  122. #   4656 -rw-r--r-- op/op.zweispring
  123. #   4548 -rw-r--r-- def.english
  124. #   4581 -rw-r--r-- def.german
  125. #   7830 -rw-r--r-- man
  126. #  11920 -rw-r--r-- Makefile
  127. #
  128. if test -r _shar_seq_.tmp; then
  129.     echo 'Must unpack archives in sequence!'
  130.     echo Please unpack part `cat _shar_seq_.tmp` next
  131.     exit 1
  132. fi
  133. # ============= README.eng ==============
  134. if test -f 'README.eng' -a X"$1" != X"-c"; then
  135.     echo 'x - skipping README.eng (File already exists)'
  136.     rm -f _shar_wnt_.tmp
  137. else
  138. > _shar_wnt_.tmp
  139. echo 'x - extracting README.eng (Text)'
  140. sed 's/^X//' << 'SHAR_EOF' > 'README.eng' &&
  141. X            --------------------------------
  142. X            Installation off UnixChess V2.7:
  143. X            --------------------------------
  144. X
  145. o    Look up the 'Makefile' and make any necessary changes (e.g. if
  146. X    you need other pathnames).
  147. X
  148. o    Do a test installation in the source directory by simply
  149. X    typing 'make'.
  150. X
  151. o    If everything works fine, install finaly with 'make install'.
  152. X    Important: Just copying the files for installation won't
  153. X    work, because the pathnames won't be set up correctly.
  154. X
  155. o    If you want to install the manual, type 'make install_man'.
  156. X    Unfortunately, I've only a german manual. Perhaps there is
  157. X    someone who is good enough in english and german to translate
  158. X    it and post it ?
  159. X
  160. o    Let the 'cron' run 'xchess -e' (expire) exactly once a day.
  161. X
  162. o    If you have any problems, send an email to 'ml@brumuc.muc.sub.org'.
  163. X
  164. X
  165. X    
  166. SHAR_EOF
  167. chmod 0644 README.eng ||
  168. echo 'restore of README.eng failed'
  169. Wc_c="`wc -c < 'README.eng'`"
  170. test 808 -eq "$Wc_c" ||
  171.     echo 'README.eng: original size 808, current size' "$Wc_c"
  172. rm -f _shar_wnt_.tmp
  173. fi
  174. # ============= README.ger ==============
  175. if test -f 'README.ger' -a X"$1" != X"-c"; then
  176.     echo 'x - skipping README.ger (File already exists)'
  177.     rm -f _shar_wnt_.tmp
  178. else
  179. > _shar_wnt_.tmp
  180. echo 'x - extracting README.ger (Text)'
  181. sed 's/^X//' << 'SHAR_EOF' > 'README.ger' &&
  182. X            --------------------------------
  183. X            Installieren von UnixChess V2.7:
  184. X            --------------------------------
  185. X
  186. o    Im 'Makefile' Eintraege ggf. aendern (falls z.B. andere Pfade
  187. X    gewuenscht sind).
  188. X
  189. o    Mit 'make' zum Test im aktuellen Directory installieren.
  190. X
  191. o    Mit 'make install' endgueltig installieren. WICHTIG: Nicht
  192. X    einfach durch Kopieren der Files installieren, da dann die
  193. X    Pfadnamen nicht richtig gesetzt werden !
  194. X
  195. o    Mit 'make install_man' Dokumentation installieren.
  196. X
  197. o    'xchess -e' (expire) einmal taeglich von 'cron' ausfuehren lassen.
  198. X
  199. o    Probleme, Verbesserungsvorschlaege, Inkompatibilitaeten bitte
  200. X    an 'ml@brumuc.muc.sub.org' senden.
  201. X
  202. SHAR_EOF
  203. chmod 0644 README.ger ||
  204. echo 'restore of README.ger failed'
  205. Wc_c="`wc -c < 'README.ger'`"
  206. test 651 -eq "$Wc_c" ||
  207.     echo 'README.ger: original size 651, current size' "$Wc_c"
  208. rm -f _shar_wnt_.tmp
  209. fi
  210. # ============= ch/value.c ==============
  211. if test ! -d 'ch'; then
  212.     echo 'x - creating directory ch'
  213.     mkdir 'ch'
  214. fi
  215. if test -f 'ch/value.c' -a X"$1" != X"-c"; then
  216.     echo 'x - skipping ch/value.c (File already exists)'
  217.     rm -f _shar_wnt_.tmp
  218. else
  219. > _shar_wnt_.tmp
  220. echo 'x - extracting ch/value.c (Text)'
  221. sed 's/^X//' << 'SHAR_EOF' > 'ch/value.c' &&
  222. /****************************************************************/
  223. /*                                */
  224. /*    XChess V2.7: Stellung bewerten                */
  225. /*                                */
  226. /*    (c) 1991 by Marc Laukien                */
  227. /*                                */
  228. /****************************************************************/
  229. X
  230. #include "ch.h"            /* Def. des Schachspiels     */
  231. #include "ph.h"            /* Def. der Spielphasen        */
  232. X
  233. static long bewerte2();        /* Vorwaertsdeklaration        */
  234. X
  235. /****************************************************************/
  236. /*    Stellung bewerten                    */
  237. /****************************************************************/
  238. /*    Return:    Stellungwert                    */
  239. /****************************************************************/
  240. X
  241. long bewerte(dat,pos)
  242. X
  243. SPDAT     *dat;            /* Spieldaten    */
  244. BYTE    pos;            /* einzelne Position    */
  245. {
  246. X    BYTE        i,j;        /* Zaehler        */
  247. X    long        wert=0L;    /* Wert der Position    */
  248. X
  249. X    if(!pos)        /* komplett berechnenen ?    */
  250. X    for(j=0;j<8;j++)    /* alle Felder durchgehen    */
  251. X        for(i=0;i<8;i++)
  252. X            wert += bewerte2(dat,i,j);    /* berechnen    */
  253. X    else                 /* nur eine Position berechnen    */
  254. X    {
  255. X        i=_xpos(pos);            /* Koordinaten best.    */
  256. X        j=_ypos(pos);
  257. X
  258. X        wert = bewerte2(dat,i,j);    /* berechnen    */
  259. X    }
  260. X
  261. X    return(wert);        /* Stellungswert zurueckgeben    */
  262. }
  263. X
  264. static long bewerte2(dat,i,j)
  265. X
  266. SPDAT     *dat;            /* Spieldaten    */
  267. BYTE    i,j;            /* zu bewertende Position    */
  268. {
  269. X    static long fig_wert[]=    /* Wert der Figuren    */
  270. X    {0L,100L,100L,300L,300L,500L,500L,900L,MATT,MATT};
  271. X
  272. X    BYTE    fig;            /* Figur        */
  273. X    long    wert=0;            /* Wert der Position    */
  274. X    BYTE    pos;            /* Position        */
  275. X
  276. X    pos=ZLEN*(j+RAND)+i+RAND;    /* Position berechnen    */
  277. X
  278. X    fig=dat->brett[pos];        /* Figur bestimmen    */
  279. X
  280. X    wert = fig_wert[_figur(fig)];    /* Wert der Figur     */
  281. X
  282. X    if(phase==EROEFF)        /* Eroeffnungsphase ?    */
  283. X    {
  284. X        /**** Postionsboni Eroeffnung ****/
  285. X        static long bau_add[][8]=
  286. X        {
  287. X        0L,    0L,    0L,    0L,    0L,    0L,    0L,    0L,
  288. X        0L,    0L,    0L,    0L,    0L,    0L,    0L,    0L,
  289. X        0L,    0L,    20L,    20L,    20L,    20L,    0L,    0L,
  290. X        0L,    0L,    20L,    50L,    50L,    20L,    0L,    0L,
  291. X        0L,    0L,    20L,    50L,    50L,    20L,    0L,    0L,
  292. X        0L,    0L,    20L,    20L,    20L,    20L,    0L,    0L,
  293. X        0L,    0L,    0L,    0L,    0L,    0L,    0L,    0L,
  294. X        0L,    0L,    0L,    0L,    0L,    0L,    0L,    0L,
  295. X        };
  296. X
  297. X        static long spr_add[][8]=
  298. X        {
  299. X        -50L,    0L,    0L,    0L,    0L,    0L,    0L,    -50L,
  300. X        -20L,    0L,    0L,    0L,    0L,    0L,    0L,    -20L,
  301. X        -20L,    0L,    0L,    50L,    50L,    0L,    0L,    -20L,
  302. X        -20L,    10L,    40L,    50L,    50L,    40L,    10L,    -20L,
  303. X        -20L,    10L,    30L,    50L,    50L,    30L,    10L,    -20L,
  304. X        -20L,    0L,    30L,    10L,    10L,    30L,    0L,    -20L,
  305. X        -20L,    0L,    0L,    0L,    0L,    0L,    0L,    -20L,
  306. X        -50L,    0L,    0L,    0L,    0L,    0L,    0L,    -50L,
  307. X        };
  308. X
  309. X        static long lae_add[][8]=
  310. X        {
  311. X        0L,    0L,    0L,    0L,    0L,    0L,    0L,    0L,
  312. X        0L,    0L,    0L,    0L,    0L,    0L,    0L,    0L,
  313. X        0L,    0L,    0L,    0L,    0L,    0L,    0L,    0L,
  314. X        0L,    50L,    0L,    0L,    0L,    0L,    20L,    0L,
  315. X        10L,    0L,    10L,    0L,    0L,    10L,    0L,    10L,
  316. X        0L,    0L,    0L,    20L,    20L,    0L,    0L,    0L,
  317. X        0L,    0L,    50L,    0L,    10L,    0L,    0L,    0L,
  318. X        0L,    0L,    0L,    0L,    0L,    0L,    0L,    0L,
  319. X        };    
  320. X
  321. X        static long koe_add[][8]=
  322. X        {
  323. X        -20L,    -20L,    -20L,    -20L,    -20L,    -20L,    -20L,    -20L,
  324. X        -20L,    -20L,    -20L,    -20L,    -20L,    -20L,    -20L,    -20L,
  325. X        -20L,    -20L,    -20L,    -20L,    -20L,    -20L,    -20L,    -20L,
  326. X        -20L,    -20L,    -20L,    -20L,    -20L,    -20L,    -20L,    -20L,
  327. X        -20L,    -20L,    -20L,    -20L,    -20L,    -20L,    -20L,    -20L,
  328. X        -20L,    -20L,    -20L,    -20L,    -20L,    -20L,    -20L,    -20L,
  329. X        -20L,    -20L,    -20L,    -20L,    -20L,    -20L,    -20L,    -20L,
  330. X        -20L,     60L,     60L,      0L,    -10L,      0L,     60L,    -20L,
  331. X        };
  332. X
  333. X        switch(_figur(fig))        /* Positionsboni    */
  334. X        {
  335. X        case BAU:            /* Bauer        */
  336. X        case XBAU:
  337. X            wert += bau_add[_farbe(fig)==SCH?j:7-j][i];
  338. X            break;
  339. X
  340. X        case SPR:            /* Springer        */
  341. X            wert += spr_add[_farbe(fig)==SCH?j:7-j][i];
  342. X            break;
  343. X
  344. X        case LAE:            /* Laeufer        */
  345. X            wert += lae_add[_farbe(fig)==SCH?j:7-j][i];
  346. X            break;
  347. X
  348. X        case KOE:            /* Koenig        */
  349. X        case XKOE:
  350. X            wert += koe_add[_farbe(fig)==SCH?j:7-j][i];
  351. X            break;
  352. X        }
  353. X    }
  354. X    else if(phase==MITTEL)            /* Mittelspiel ?    */
  355. X    {
  356. X        /*** Reihenboni Mittelspiel    (gilt fuer Turm)    ***/
  357. X        static long add[]={0L,5L,10L,15L,20L,25L,40L,50L};
  358. X
  359. X        if(!_istkoe(fig))
  360. X            wert += (fig_wert[_figur(fig)]*
  361. X            add[_farbe(fig)==WEI ? j:7-j])/fig_wert[TUR];
  362. X    }
  363. X    else if(phase==ENDSPI || phase==WKOEOO || phase==SKOEOO)    
  364. X    {                    /* Endspiel ?        */
  365. X        /*** Positionsboni fuer Koenig                ***/
  366. X        static long koe_add[][8]=
  367. X        {
  368. X        -80L,    -60L,    -30L,    -30L,    -30L,    -30L,    -60L,    -80L,
  369. X        -60L,    -30L,    -10L,    -10L,    -10L,    -10L,    -30L,    -60L,
  370. X        -30L,    -10L,      0L,      0L,      0L,      0L,    -10L,    -30L,
  371. X        -30L,    -10L,      0L,      0L,      0L,      0L,    -10L,    -30L,
  372. X        -30L,    -10L,      0L,      0L,      0L,      0L,    -10L,    -30L,
  373. X        -30L,    -10L,      0L,      0L,      0L,      0L,    -10L,    -30L,
  374. X        -60L,    -30L,    -10L,    -10L,    -10L,    -10L,    -30L,    -30L,
  375. X        -80L,    -60L,    -30L,    -30L,    -30L,    -30L,    -60L,    -60L,
  376. X        };
  377. X
  378. X        /*** Reihenboni Endspiel fuer Bauer            ***/
  379. X        static long add[]={0L,5L,10L,15L,20L,25L,30L,35L};
  380. X
  381. X        if(_istbau(fig))            /* Bauern vor     */
  382. X            wert += add[_farbe(fig)==WEI ? j:7-j];
  383. X
  384. X        if(phase==WKOEOO || phase==SKOEOO)    /* Koe. o. Offiziere*/
  385. X        if(_istkoe(fig))
  386. X        {
  387. X            int     abstand;
  388. X
  389. X            abstand=abs((int)(_xpos(dat->wkpos)-_xpos(dat->skpos)))
  390. X                   +abs((int)(_ypos(dat->wkpos)-_ypos(dat->skpos)));
  391. X
  392. X            if(_istwei(fig))
  393. X            {
  394. X            if(phase==WKOEOO)    /* nicht an den Rand    */
  395. X                wert+= koe_add[_farbe(fig)==SCH?j:7-j][i];
  396. X            else            /* Koenig in Opposition    */
  397. X                wert-= abstand * 10;
  398. X            }
  399. X            else if(_istsch(fig))
  400. X            {
  401. X            if(phase==SKOEOO)    /* nicht an den Rand    */
  402. X                wert+= koe_add[_farbe(fig)==SCH?j:7-j][i];
  403. X            else            /* Koenig in Opposition    */
  404. X                wert-= abstand * 10;
  405. X            }
  406. X        }
  407. X    }
  408. X
  409. X    wert *= _farbe(fig) == WEI ? 1L:-1L;    /* Vorzeichen        */
  410. X
  411. X    return(wert);
  412. }
  413. SHAR_EOF
  414. chmod 0644 ch/value.c ||
  415. echo 'restore of ch/value.c failed'
  416. Wc_c="`wc -c < 'ch/value.c'`"
  417. test 5280 -eq "$Wc_c" ||
  418.     echo 'ch/value.c: original size 5280, current size' "$Wc_c"
  419. rm -f _shar_wnt_.tmp
  420. fi
  421. # ============= ch/main.c ==============
  422. if test -f 'ch/main.c' -a X"$1" != X"-c"; then
  423.     echo 'x - skipping ch/main.c (File already exists)'
  424.     rm -f _shar_wnt_.tmp
  425. else
  426. > _shar_wnt_.tmp
  427. echo 'x - extracting ch/main.c (Text)'
  428. sed 's/^X//' << 'SHAR_EOF' > 'ch/main.c' &&
  429. /****************************************************************/
  430. /*                                */
  431. /*    XChess V2.7: Hauptprogramm                */
  432. /*                                */
  433. /*    (c) 1991 by Marc Laukien                */
  434. /*                                */
  435. /****************************************************************/
  436. X
  437. #include <string.h>
  438. #include "ch.h"            /* Def. des Schachspiels     */
  439. X
  440. int    opnr;            /* Anzahl der Eroeffnungen    */
  441. int    testopnr;        /* Eroeffnungsnummer zum testen */
  442. WORD    *op[MAXOP];        /* Zeiger auf die Eroeffnungen    */
  443. BYTE    op_fa[MAXOP];        /* Farbe fuer die Eroeff. gilt    */
  444. int    noop;            /* 1-Keine Eroeffnungsbib. mehr    */
  445. SPDAT    spdat;            /* Alle Spieldaten         */
  446. ARCHIV    *archiv[MAXSP];        /* Archiv der Positionen    */
  447. int    phase;            /* Spielphase            */
  448. int    zaehler;        /* Antwortzaehler        */
  449. int    compzuege;        /* Computerzuege        */
  450. long    varianten;        /* Zaehler fuer die Varianten    */
  451. long    zeit;            /* Dauer des letzten Zuges    */
  452. long    varprosek;        /* Varianten pro Sekunde    */
  453. int    stufe=0;        /* Spielstufe            */
  454. int    beende;            /* Falls 1 Denkvorgang beenden    */
  455. WORD    best_so_far;        /* Bester Zug bis jetzt        */
  456. X
  457. int    mode=2+4+8+32+128;    /* Modus            */
  458. X                /* 1   :Analyse    ausfuehrlich    */
  459. X                /* 2   :Alpha-Beta-Abschneidung    */
  460. X                /* 4   :Vorsortieren        */
  461. X                /* 8   :Stufenanpassung        */
  462. X                /* 16  :Koenigsbedrohung immer    */
  463. X                /*      ueberpruefen        */
  464. X                /* 32  :Eroeffnungsbib. ein    */
  465. X                /* 64  :Eroeffnungsnr = testopnr*/
  466. X                /* 128 :Analyse einfach        */
  467. X
  468. X                /* Status des letzten Zuges:    */
  469. int    schlag;            /* falls 1 wurde geschlagen    */
  470. X                /* oder befoerdert        */
  471. int    gabel;            /* Bauernspiess oder        */
  472. X                /* Springergabel        */
  473. X
  474. X                /* maximal und minimale Rechentiefe    */
  475. int    mintiefe[]={2,2,  3,3,  4,4,  5,5,   6,6 };
  476. int    maxtiefe[]={4,6,  6,8,  6,8,  8,10,  8,10};
  477. X
  478. extern    long    time();
  479. extern    char    *malloc();
  480. extern    char    *memcpy();
  481. extern    void    free();
  482. X
  483. /****************************************************************/
  484. /*    Hauptprogramm                        */
  485. /****************************************************************/
  486. /*    Return: Anzahl der Antworten in ret            */
  487. /****************************************************************/
  488. X
  489. schach(str,ret)
  490. X
  491. char *str;                    /* Kommandostring    */
  492. char *ret[];                    /* Antworten        */
  493. {
  494. X    char cmd[STRLEN];            /* Kommando        */
  495. X
  496. X    zaehler=0;                /* noch keine Antwort    */
  497. X    beende=0;                /* nicht beenden    */
  498. X    best_so_far=(WORD)0;            /* noch kein Zug    */
  499. X
  500. X    sscanf(str,"%s",cmd);            /* Kommando einlesen    */
  501. X
  502. X    strcpy(ret[zaehler],"ok");        /* loeschen        */
  503. X
  504. X    if(!strcmp(cmd,"init"))
  505. X        init(&spdat,1);            /* Initialisierungen    */
  506. X    else if(!strcmp(cmd,"loeschen"))
  507. X        init(&spdat,0);            /* Brett loeschen    */
  508. X    else if(!strcmp(cmd,"brett"))
  509. X        brett_aus(&spdat,ret);        /* Brett zeigen        */
  510. X    else if(!strcmp(cmd,"info"))
  511. X        info_aus(&spdat,ret);       /* Informationen    */
  512. X    else if(!strcmp(cmd,"status"))
  513. X        status_aus(&spdat,ret);      /* Statusinformationen    */
  514. X    else if(!strcmp(cmd,"weiss"))
  515. X    {
  516. X        spdat.farbe=WEI;          /* Weiss am Zug        */
  517. X        noop=0;
  518. X    }
  519. X    else if(!strcmp(cmd,"schwarz"))
  520. X    {
  521. X        spdat.farbe=SCH;          /* Schwarz am Zug    */
  522. X        noop=0;
  523. X    }
  524. X    else if(!strcmp(cmd,"testbib"))        /* Bibl. testen        */
  525. X    {
  526. X        if(!bib_test())
  527. X            strcpy(ret[zaehler++],"?");    /* Fehler    */
  528. X    }
  529. X    else if(!strcmp(cmd,"zurueck"))       /* Zug zurueck        */
  530. X    {
  531. X        if(!hole_zurueck(&spdat,spdat.zuege-1))
  532. X            strcpy(ret[zaehler++],"?");    /* Fehler    */
  533. X        else
  534. X        {
  535. X            free(archiv[spdat.zuege+1]);    /* freigeben    */
  536. X            archiv[spdat.zuege+1]=(ARCHIV *)0;
  537. X
  538. X            noop=OPTRYS;        /* Eroeffnungsbibl. ein    */
  539. X            varianten=0;        /* Keine Varianten    */
  540. X        }
  541. X    }
  542. X    else if(!strcmp(cmd,"zliste"))
  543. X    {
  544. X        zugliste(&spdat,(BYTE)0);    /* Zugliste erstellen    */
  545. X        zugliste_aus(&spdat,0,ret);    /* Zugliste zeigen    */
  546. X    }
  547. X    else if(!strcmp(cmd,"spiel"))
  548. X    {
  549. X        int i;
  550. X
  551. X        for(i=1;i<=spdat.zuege;i++)    /* alle Zuege durchgehen*/
  552. X            sprintf(ret[zaehler++],"%3d: %s",i
  553. X            ,wandle(_apos(archiv[i]->lzug)
  554. X            ,_npos(archiv[i]->lzug)));
  555. X    }
  556. X    else if(!strcmp(cmd,"save"))
  557. X    {
  558. X        char name[STRLEN];
  559. X
  560. X        name[0]=0;                /* loeschen    */
  561. X        strcpy(name,str+strlen(cmd));        /* kopieren    */
  562. X
  563. X        if(name[0]==0)                /* kein Name ?    */
  564. X            strcpy(ret[zaehler++],"?");    /* Fehler    */
  565. X        else if(!save_game(name))        /* Speichern    */
  566. X            strcpy(ret[zaehler++],"?");    /* Fehler    */
  567. X    }
  568. X    else if(!strcmp(cmd,"load"))
  569. X    {
  570. X        char name[STRLEN];
  571. X
  572. X        name[0]=0;                /* loeschen    */
  573. X        strcpy(name,str+strlen(cmd));        /* kopieren    */
  574. X
  575. X        if(name[0]==0)                /* kein Name ?    */
  576. X            strcpy(ret[zaehler++],"?");    /* Fehler    */
  577. X        else if(!load_game(name))        /* Laden    */
  578. X            strcpy(ret[zaehler++],"?");    /* Fehler    */
  579. X    }
  580. X    else if(!strcmp(cmd,"loadinfo"))
  581. X    {
  582. X        SPDAT    dat;            /* Spieldaten        */
  583. X        char     name[STRLEN];
  584. X
  585. X        name[0]=0;                /* loeschen    */
  586. X        strcpy(name,str+strlen(cmd));        /* kopieren    */
  587. X
  588. X        if(name[0]==0)                /* kein Name ?    */
  589. X            strcpy(ret[zaehler++],"?");    /* Fehler    */
  590. X        else
  591. X        {
  592. X            if(!load_spdat(name,&dat))    /* Laden    */
  593. X                strcpy(ret[zaehler++],"?");/* Fehler    */
  594. X            else
  595. X                info_aus(&dat,ret);       /* Informationen*/
  596. X        }
  597. X    }
  598. X    else if(!strcmp(cmd,"ziehe"))
  599. X    {
  600. X        WORD zug;
  601. X
  602. X        if(!(zug=wandle_inv(str+strlen(cmd))))
  603. X            strcpy(ret[zaehler++],"?");    /* Fehler    */
  604. X        else if(!zug_test(&spdat,zug))        /* Testen    */
  605. X            strcpy(ret[zaehler++],"?");    /* Fehler    */
  606. X        else
  607. X        {
  608. X            ziehe(&spdat,zug);        /* ziehen    */
  609. X            archiviere(&spdat);        /* speichern    */
  610. X        }
  611. X    }
  612. X    else if(!strcmp(cmd,"setze"))
  613. X    {
  614. X        BYTE pos;                /* Position    */
  615. X        char *str2;
  616. X        BYTE fig;                                /* Figur    */
  617. X
  618. X        str2=str+strlen(cmd);
  619. X        while(*str2==' ')
  620. X            str2++;
  621. X
  622. X        if((fig=wandle_fig(*str2))==0)        /* Figur holen    */
  623. X            strcpy(ret[zaehler++],"?");    /* Fehler    */
  624. X        else
  625. X        {
  626. X            str2++;
  627. X
  628. X            if(!(pos=(BYTE)wandle_inv(str2)))
  629. X                strcpy(ret[zaehler++],"?");/* Fehler    */
  630. X            else
  631. X            {
  632. X            if(    /* Keine 2 Koenige !        */
  633. X            (_istkoe(fig) && _istwei(fig)
  634. X            && spdat.wkpos!=(BYTE)0) ||
  635. X            (_istkoe(fig) && _istsch(fig)
  636. X            && spdat.skpos!=(BYTE)0))
  637. X                    strcpy(ret[zaehler++],"?");/* Fehler */
  638. X            else
  639. X            {
  640. X                spdat.brett[pos]=fig;    /* setzen    */
  641. X                noop=0;        /* Bib. schliessen    */
  642. X
  643. X                if(pos==spdat.wkpos) /* Koenig loeschen ? */
  644. X                    spdat.wkpos=(BYTE)0;
  645. X
  646. X                if(pos==spdat.skpos) /* Koenig loeschen ? */
  647. X                    spdat.skpos=(BYTE)0;
  648. X
  649. X                if(_istkoe(fig))     /* Koenig ?    */
  650. X                {     /* Positionen eintragen    */
  651. X                    if(_istwei(fig))
  652. X                        spdat.wkpos=pos;
  653. X
  654. X                    if(_istsch(fig))
  655. X                        spdat.skpos=pos;
  656. X                }
  657. X            }
  658. X            }
  659. X        }
  660. X    }
  661. X    else if(!strcmp(cmd,"comp"))
  662. X    {
  663. X        WORD    bzug[MAXTIEFE];    /* Beste Zugkombination        */
  664. X
  665. X        varianten=0;
  666. X        zeit=time((long *)0);            /* Zeit merken    */
  667. X
  668. X        spdat.wert=bewerte(&spdat,0);        /* Stellungswert*/
  669. X        eff_stufe(&spdat);            /* Rechentiefe    */
  670. X
  671. X        if((spdat.bzug=bib_zug())==(WORD)0)/* Kein Zug in Bib. ?*/
  672. X        {
  673. X            comp_zug(&spdat,spdat.farbe==WEI ? MATT:-MATT,
  674. X            bzug);                /* besten Zug     */
  675. X        }
  676. X
  677. X        if(zug_test(&spdat,spdat.bzug))        /* Testen    */
  678. X        {
  679. X            ziehe(&spdat,spdat.bzug);    /* ziehen    */
  680. X            archiviere(&spdat);        /* speichern    */
  681. X
  682. X            zeit=time((long *)0)-zeit;    /* Zeitdifferenz*/
  683. X            if(varianten>0)            /* Computerzug ?*/
  684. X            if(++compzuege<=50)        /* Kein Ueberlauf */
  685. X            varprosek+=varianten/((long)zeit>0 ? (long)zeit:1L);
  686. X        }
  687. X        else    /* Fehler, z.B. in der Bibliothek ?    */
  688. X            noop=0;    /* schliessen    */
  689. X    }
  690. X    else if(!strcmp(cmd,"bliste"))
  691. X    {
  692. X        WORD    bzug[MAXTIEFE];    /* Beste Zugkombination        */
  693. X        varianten=0;
  694. X
  695. X        zeit=time((long *)0);            /* Zeit merken    */
  696. X        spdat.wert=bewerte(&spdat,0);        /* Stellungswert*/
  697. X        eff_stufe(&spdat);            /* Rechentiefe    */
  698. X        comp_zug(&spdat,spdat.farbe==
  699. X        WEI ? MATT:-MATT,bzug);            /* besten Zug     */
  700. X        zeit=time((long *)0)-zeit;        /* Zeitdifferenz*/
  701. X        if(varianten>0)                /* Computerzug ?*/
  702. X        if(++compzuege<=50)            /* Kein Ueberlauf */
  703. X        varprosek+=varianten/((long)zeit>0 ? (long)zeit:1L);
  704. X        zugliste_aus(&spdat,1,ret);        /* Zugliste zeigen*/
  705. X    }
  706. X    else if(!strcmp(cmd,"modus"))    /* Modus einstellen    */
  707. X        sscanf(str+strlen(cmd),"%d",&mode);
  708. X    else if(!strcmp(cmd,"stufe"))    /* Stufe einstellen    */
  709. X    {
  710. X        sscanf(str+strlen(cmd),"%d",&stufe);
  711. X        eff_stufe(&spdat);    /* Rechentiefe    */
  712. X    }
  713. X    else if(!strcmp(cmd,"wert"))
  714. X        sprintf(ret[zaehler++],"%ld",bewerte(&spdat,0));
  715. X    else
  716. X        strcpy(ret[zaehler++],"?");
  717. X
  718. X    return(zaehler);        /* Anzahl der Antworten zurueck    */
  719. }
  720. SHAR_EOF
  721. chmod 0644 ch/main.c ||
  722. echo 'restore of ch/main.c failed'
  723. Wc_c="`wc -c < 'ch/main.c'`"
  724. test 7880 -eq "$Wc_c" ||
  725.     echo 'ch/main.c: original size 7880, current size' "$Wc_c"
  726. rm -f _shar_wnt_.tmp
  727. fi
  728. # ============= ch/move.c ==============
  729. if test -f 'ch/move.c' -a X"$1" != X"-c"; then
  730.     echo 'x - skipping ch/move.c (File already exists)'
  731.     rm -f _shar_wnt_.tmp
  732. else
  733. > _shar_wnt_.tmp
  734. echo 'x - extracting ch/move.c (Text)'
  735. sed 's/^X//' << 'SHAR_EOF' > 'ch/move.c' &&
  736. /****************************************************************/
  737. /*                                */
  738. /*    XChess V2.7: Zug ausfuehren                */
  739. /*                                */
  740. /*    (c) 1991 by Marc Laukien                */
  741. /*                                */
  742. /****************************************************************/
  743. X
  744. #include "ch.h"            /* Def. des Schachspiels */
  745. X
  746. /****************************************************************/
  747. /*    Zug ausfuehren                        */
  748. /****************************************************************/
  749. /*    Return:    1: es wurde Rochiert oder e.p. geschl.        */
  750. /****************************************************************/
  751. X
  752. int    ziehe(dat,zug)
  753. X
  754. SPDAT    *dat;                /* Spieldaten     */
  755. WORD    zug;                /* auszuf. Zug    */
  756. {
  757. X    BYTE    afig;            /* alte Figur    */
  758. X    BYTE    npos,apos;        /* neue und alte Pos.    */
  759. X    int    epro=0;            /* falls ep. od. Roch.    */
  760. X
  761. X                    /* Status des letzten Zuges:    */
  762. X    schlag=0;            /* falls 1 wurde geschlagen    */
  763. X                    /* oder befoerdert        */
  764. X    gabel=0;            /* Bauernspiess oder        */
  765. X                    /* Springergabel        */
  766. X
  767. X    npos=_npos(zug);        /* Pos. berechnen    */
  768. X    apos=_apos(zug);
  769. X
  770. X    afig=dat->brett[apos];        /* alte Figur holen    */
  771. X
  772. X    switch(_figur(afig))           /* Umwandlungen ?    */
  773. X    {
  774. X    case BAU:            /* Befoerderung        */
  775. X        if(_istspz(dat->brett[npos+ZLEN]))
  776. X        {
  777. X            afig=DAM|WEI;
  778. X            schlag=1;
  779. X        }
  780. X        else if(_istspz(dat->brett[npos-ZLEN]))
  781. X        {
  782. X            afig=DAM|SCH;
  783. X            schlag=1;
  784. X        }
  785. X                    /* schlagen en passant    */
  786. X        else if(_istlee(dat->brett[npos]))
  787. X            switch((short)npos-(short)apos)
  788. X            {
  789. X            case 13:    /* rechts loeschen    */
  790. X            case -11:
  791. X                dat->brett[apos+1]=LEE;
  792. X                schlag=1;
  793. X                epro=1;
  794. X                break;
  795. X
  796. X            case 11:    /* links loeschen    */
  797. X            case -13:
  798. X                dat->brett[apos-1]=LEE;
  799. X                schlag=1;
  800. X                epro=1;
  801. X                break;
  802. X            }
  803. X
  804. X        switch((short)npos-(short)apos)
  805. X        {
  806. X        case 12:    /* Bauernspiess    weiss ?    */
  807. X            if(_istnsch(dat->brett[npos+13]) &&
  808. X              !_istbau(dat->brett[npos+13]) &&
  809. X               _istnsch(dat->brett[npos+11]) &&
  810. X              !_istbau(dat->brett[npos+11]))
  811. X                gabel=1;
  812. X            break;
  813. X
  814. X        case -12:    /* Bauernspiess    schwarz ?*/
  815. X            if(_istnwei(dat->brett[npos-13]) &&
  816. X              !_istbau(dat->brett[npos-13]) &&
  817. X               _istnwei(dat->brett[npos-11]) &&
  818. X              !_istbau(dat->brett[npos-11]))
  819. X                gabel=1;
  820. X            break;
  821. X        }
  822. X        break;
  823. X
  824. X    case XBAU:            /* Spezialfig. normal    */
  825. X        afig=BAU | _farbe(afig);
  826. X        switch((short)npos-(short)apos)
  827. X        {
  828. X        case 12:    /* Bauernspiess    weiss ?    */
  829. X            if(_istnsch(dat->brett[npos+13]) &&
  830. X              !_istbau(dat->brett[npos+13]) &&
  831. X               _istnsch(dat->brett[npos+11]) &&
  832. X              !_istbau(dat->brett[npos+11]))
  833. X                gabel=1;
  834. X            break;
  835. X
  836. X        case -12:    /* Bauernspiess    schwarz ?*/
  837. X            if(_istnwei(dat->brett[npos-13]) &&
  838. X              !_istbau(dat->brett[npos-13]) &&
  839. X               _istnwei(dat->brett[npos-11]) &&
  840. X              !_istbau(dat->brett[npos-11]))
  841. X                gabel=1;
  842. X            break;
  843. X        }
  844. X        break;
  845. X
  846. X    case XTUR:
  847. X        afig=TUR | _farbe(afig);
  848. X        break;
  849. X
  850. X    case XKOE:
  851. X        afig=KOE | _farbe(afig);
  852. X
  853. X        if((short)npos-(short)apos==2)    /* kurze Rochade    */
  854. X        {
  855. X            epro=1;
  856. X            dat->brett[apos+1]=TUR | _farbe(afig);
  857. X            dat->brett[npos+1]=LEE;
  858. X        }
  859. X        if((short)npos-(short)apos==-2)    /* lange Rochade    */
  860. X        {
  861. X            epro=1;
  862. X            dat->brett[apos-1]=TUR | _farbe(afig);
  863. X            dat->brett[npos-2]=LEE;
  864. X        }
  865. X
  866. X    case KOE:                /* Koenigspositionen    */
  867. X        if(_istwei(afig))
  868. X            dat->wkpos=npos;
  869. X        else
  870. X            dat->skpos=npos;
  871. X        break;
  872. X    }
  873. X
  874. X    if(!_istlee(dat->brett[npos]))        /* schlagen ?        */
  875. X    {
  876. X        schlag=1;
  877. X        if(_istkoe(dat->brett[npos]))    /* Koenig geschlagen ?     */
  878. X                        /* (theor., d.h. matt)    */
  879. X        {
  880. X            if(_istwei(dat->brett[npos]))
  881. X                dat->wkpos=(BYTE)0;    /* loeschen    */
  882. X            else
  883. X                dat->skpos=(BYTE)0;    /* loeschen    */
  884. X        }
  885. X    }
  886. X    dat->brett[apos]=LEE;            /* loeschen        */
  887. X    dat->brett[npos]=afig;            /* neu setzen        */
  888. X    dat->farbe=dat->farbe==WEI ? SCH:WEI;    /* Farbe aendern    */
  889. X    dat->lzug=zug;                /* letzter Zug        */
  890. X    dat->zuege++;                /* ein Zug mehr        */
  891. X
  892. X    return(epro);
  893. }
  894. X
  895. /****************************************************************/
  896. /*    Zug testen                        */
  897. /****************************************************************/
  898. /*    Return: 1: Zug moeglich,    0: nicht mgl.        */
  899. /****************************************************************/
  900. X
  901. int    zug_test(dat,zug)
  902. X
  903. SPDAT     *dat;                /* Spieldaten        */
  904. WORD     zug;                /* zu testender Zug    */
  905. {
  906. X    int     anz;            /* Anzahl der Zuege    */
  907. X
  908. X    if(dat->zuege+5 >= MAXSP)    /* Grenze erreicht    */
  909. X        return(0);        /* +5 ist Sicherheit    */
  910. X
  911. X    anz=zugliste(dat,_apos(zug));    /* Liste holen        */
  912. X
  913. X    while(--anz>=0)            /* alle testen        */
  914. X        if(zug==dat->zlist[anz])
  915. X            return(1);
  916. X
  917. X    return(0);                    /* nicht gefunden    */
  918. }
  919. SHAR_EOF
  920. chmod 0644 ch/move.c ||
  921. echo 'restore of ch/move.c failed'
  922. Wc_c="`wc -c < 'ch/move.c'`"
  923. test 4354 -eq "$Wc_c" ||
  924.     echo 'ch/move.c: original size 4354, current size' "$Wc_c"
  925. rm -f _shar_wnt_.tmp
  926. fi
  927. # ============= ch/comp.c ==============
  928. if test -f 'ch/comp.c' -a X"$1" != X"-c"; then
  929.     echo 'x - skipping ch/comp.c (File already exists)'
  930.     rm -f _shar_wnt_.tmp
  931. else
  932. > _shar_wnt_.tmp
  933. echo 'x - extracting ch/comp.c (Text)'
  934. sed 's/^X//' << 'SHAR_EOF' > 'ch/comp.c' &&
  935. /****************************************************************/
  936. /*                                */
  937. /*    XChess V2.7: Computerzug                */
  938. /*                                */
  939. /*    (c) 1991 by Marc Laukien                */
  940. /*                                */
  941. /****************************************************************/
  942. X
  943. #include "ch.h"            /* Def. des Schachspiels     */
  944. X
  945. #ifdef    ANALYSE
  946. static void monitor();
  947. #endif
  948. X
  949. /****************************************************************/
  950. /*    Computerzug bestimmen                    */
  951. /****************************************************************/
  952. /*    Return:    Bewertung des Zugs                */
  953. /****************************************************************/
  954. X
  955. long    comp_zug(dat,erw,bzug)
  956. X
  957. SPDAT     *dat;                    /* Spieldaten        */
  958. long    erw;                    /* Erwartungswert    */
  959. WORD    bzug[];                    /* beste Zugkombination */ 
  960. {
  961. X    SPDAT        copy;            /* Kopie der Spieldaten    */
  962. X    SPDAT        *cdat;            /* Zeiger auf Kopie    */
  963. X    WORD        bzugliste[MAXZUG][MAXTIEFE];
  964. X                        /* Liste der Zugkomb.    */
  965. X    long        wert,maxwert;        /* Bewertung         */
  966. X    int        anz=0,best=0;        /* Zaehler, bester Zug    */
  967. X    register    i,j,k;            /* Zaehler        */
  968. X    WORD        azug=0,nzug;        /* alter und neuer Zug    */
  969. X
  970. X    if(mode&4 && dat->minstufe >= 2)    /* Vorsortieren ?    */
  971. X        anz=sortliste(dat,dat->minstufe-1);
  972. X    else
  973. X        anz=zugliste(dat,(BYTE)0);
  974. X
  975. X    if(!anz)
  976. X    {
  977. X        /* MATT */
  978. X        if(dat->farbe==WEI)
  979. X            if(bedrohung(dat,dat->wkpos)||dat->wkpos==(BYTE)0)
  980. X                return(-MATT);
  981. X
  982. X        if(dat->farbe==SCH)
  983. X            if(bedrohung(dat,dat->skpos)||dat->skpos==(BYTE)0)
  984. X                return(MATT);
  985. X
  986. X        /* PATT */
  987. X        return(0L);        /* unentschieden    */
  988. X    }
  989. X
  990. X    cdat= ©            /* Zeiger bestimmen    */
  991. X
  992. X    maxwert=dat->farbe==WEI?-2*MATT:2*MATT;/* min. Bewertung    */
  993. X    /* 2 * matt damit mindestens ein Zug bei sicherem Matt aus-    */
  994. X    /* gegeben wird.                        */
  995. X
  996. X    for(i=0;i<anz;i++)        /* alle Zuege durchgehen    */
  997. X    {
  998. X        /* alles wichtige kopieren    */
  999. X
  1000. X        if(azug)        /* nur Veraenderungen kopieren    */
  1001. X        {
  1002. X            BYTE ap,np;
  1003. X
  1004. X            ap=_apos(azug);
  1005. X            np=_npos(azug);
  1006. X
  1007. X            cdat->brett[ap] = dat->brett[ap];
  1008. X            cdat->brett[np] = dat->brett[np];
  1009. X        }
  1010. X        else            /* 1. Kopie ?    */
  1011. X            for(j=0;j<GROE;j++)
  1012. X                cdat->brett[j]=dat->brett[j];
  1013. X
  1014. X        cdat->wkpos    =dat->wkpos;
  1015. X        cdat->skpos    =dat->skpos;
  1016. X        cdat->farbe    =dat->farbe;
  1017. X        cdat->lzug      =dat->lzug;
  1018. X        cdat->zuege    =dat->zuege;
  1019. X        cdat->minstufe    =dat->minstufe-1;    /* Stufe weniger*/
  1020. X        cdat->maxstufe    =dat->maxstufe-1;
  1021. X        cdat->vorher    =dat;            /* letzter Zug    */
  1022. X
  1023. X        /**** Bewertungs-Algorithmus ***/
  1024. X
  1025. X        if(!ziehe(cdat,nzug=dat->zlist[i]))    /* ziehe    */
  1026. X        {                /* Differenz bewerten    */
  1027. X            long    add;
  1028. X
  1029. X            add = -bewerte(dat,_apos(nzug));
  1030. X
  1031. X            if(!_istlee(dat->brett[_npos(nzug)]))
  1032. X                            /* geschl. ?    */
  1033. X                add -= bewerte(dat,_npos(nzug));
  1034. X
  1035. X            add += bewerte(cdat,_npos(nzug));
  1036. X
  1037. X            azug=nzug;        /* Zug merken        */
  1038. X
  1039. X            add = (add*(20L+(long)cdat->maxstufe))/20L;
  1040. X            /* ^ addiert fuer jede Stufe 5 % des Wertes.    */
  1041. X            /* Dient dazu, dass gute Zuege zuerst        */
  1042. X            /* ausgefuehrt werden.                */
  1043. X
  1044. X            cdat->wert = dat->wert + add;
  1045. X        }
  1046. X        else                /* komplett bewerten    */
  1047. X        {
  1048. X            azug=(WORD)0;
  1049. X            cdat->wert = bewerte(cdat,(BYTE)0);
  1050. X        }
  1051. X
  1052. X        /**** STUFE ERHOEHEN fuer spezielle Zuege    ****/
  1053. X
  1054. X         if(cdat->minstufe <= 0)    /* 1 oder 2 Stufen erweitern ?    */
  1055. X        {
  1056. X        if(cdat->maxstufe > 0)
  1057. X        {
  1058. X            if(schlag)    /* geschlagen oder Befoerderung    */
  1059. X                cdat->minstufe++; /* eine Stufe mehr    */
  1060. X            if(gabel)    /* Gabel oder Spiess gefunden     */
  1061. X                cdat->minstufe+=2; /* 2 Stufen mehr    */
  1062. X        }
  1063. X        }
  1064. X        else if(cdat->minstufe <= 1) /* 1 Stufe erweitern ?     */
  1065. X        {
  1066. X        if(cdat->maxstufe > 1)
  1067. X            if(gabel)    /* Gabel oder Spiess gefunden     */
  1068. X                cdat->minstufe++; /* 1 Stufe mehr    */
  1069. X        }
  1070. X
  1071. X        /**** ENDE STUFE ERHOEHEN fuer spezielle Zuege    ****/
  1072. X
  1073. X        if(mode & 128)            /* einfache Analyse ?    */
  1074. X            bzugliste[i][1]=(WORD)0;/* loeschen        */
  1075. X
  1076. X        if((&spdat==dat || &spdat==dat->vorher) /* 1. oder 2. Zug */
  1077. X        && (dat->maxstufe != dat->minstufe)) /* nicht Vorsortierung */
  1078. X        {                    /* 3fache Wdh ?    */
  1079. X            for(j=spdat.zuege;j>=0;j--)    /* Wdh. finden    */
  1080. X            if(archiv[j]->wdh != -1)
  1081. X            {
  1082. X                for(k=0;k<GROE;k++)
  1083. X                    if(cdat->brett[k]!=archiv[j]->brett[k])
  1084. X                        break;
  1085. X
  1086. X                if(k==GROE)
  1087. X                    break;    /* gefunden        */
  1088. X            }
  1089. X
  1090. X            if(j > -1)        /* 3-fache Wiederholung    */
  1091. X                wert=0L;    /* Remis        */
  1092. X            else
  1093. X                wert=comp_zug(cdat,maxwert,&bzugliste[i][1]);
  1094. X        }
  1095. X        else if(cdat->minstufe<=0)    /* Keine Stufe weiter ?    */
  1096. X        {
  1097. X            varianten++;          /* Eine Variante mehr    */
  1098. X            wert=cdat->wert        /* Keine Stufe weiter    */
  1099. X            +(rand()&0x7)-4;    /* Zufallskomponente     */
  1100. X        }
  1101. X        else                /* Eine Stufe weiter    */
  1102. X            wert=comp_zug(cdat,maxwert,&bzugliste[i][1]);
  1103. X
  1104. X        dat->blist[i]=wert;        /* Bewertungsliste    */
  1105. X
  1106. X        /**** ENDE Bewertungs-Algorithmus ****/
  1107. X
  1108. X        /**** MINIMAX-Algorithmus ****/
  1109. X
  1110. X        if(beende)            /* beenden ?        */
  1111. X            break;
  1112. X        else if(dat->farbe==WEI)      /* beste Bew. best.    */
  1113. X        {
  1114. X            if(maxwert<wert)
  1115. X            {
  1116. X            maxwert=wert;
  1117. X            best=i;
  1118. X
  1119. X            /* Bester Zug bis jetzt    */
  1120. X            if(dat == &spdat)
  1121. X                best_so_far=nzug;
  1122. X
  1123. #ifdef    ANALYSE        /* Monitorfunktion: einfache Analyse    */
  1124. X            if(mode & 128 && dat == &spdat)
  1125. X            {
  1126. X                char str[STRLEN];
  1127. X
  1128. X                bzugliste[i][0]=nzug;
  1129. X                strcpy(str,kombination(dat,bzugliste[i]));
  1130. X                sprintf(str+strlen(str)," %ld",maxwert);
  1131. X                ANALYSE(str);
  1132. X            }                /* ausgeben    */
  1133. #endif
  1134. X            }
  1135. X        }
  1136. X        else
  1137. X        {
  1138. X            if(maxwert>wert)
  1139. X            {
  1140. X            maxwert=wert;
  1141. X            best=i;
  1142. X
  1143. X            /* Bester Zug bis jetzt    */
  1144. X            if(dat == &spdat)
  1145. X                best_so_far=nzug;
  1146. X
  1147. #ifdef    ANALYSE        /* Monitorfunktion: einfache Analyse    */
  1148. X            if(mode & 128 && dat == &spdat)
  1149. X            {
  1150. X                char str[STRLEN];
  1151. X
  1152. X                bzugliste[i][0]=nzug;
  1153. X                strcpy(str,kombination(dat,bzugliste[i]));
  1154. X                sprintf(str+strlen(str)," %ld",maxwert);
  1155. X                ANALYSE(str);
  1156. X            }                /* ausgeben    */
  1157. #endif
  1158. X            }
  1159. X        }
  1160. X
  1161. X        /**** Ende MINIMAX ****/
  1162. X
  1163. X        /**** ALPHA-BETA - Abschneidung    ****/
  1164. X
  1165. X        if(wert >= erw && dat->farbe==WEI && mode&2)
  1166. X        {
  1167. #ifdef    ANALYSE
  1168. X            if(mode & 1)    /* Monitorfunktion    */
  1169. X                monitor(cdat,wert,"Abbruch");
  1170. #endif
  1171. X            break;
  1172. X        }
  1173. X        else if(wert <= erw && dat->farbe==SCH && mode&2)
  1174. X        {
  1175. #ifdef    ANALYSE
  1176. X            if(mode & 1)    /* Monitorfunktion    */
  1177. X                monitor(cdat,wert,"Abbruch");
  1178. #endif
  1179. X            break;
  1180. X        }
  1181. X
  1182. X        /**** Ende ALPHA-BETA - Algorithmus    ****/
  1183. X
  1184. #ifdef    ANALYSE
  1185. X        if(mode & 1)
  1186. X            monitor(cdat,wert,"");    /* Monitorfunktion    */
  1187. #endif
  1188. X    }
  1189. X
  1190. X    if(beende)            /* Beenden ?    */
  1191. X        if(dat == &spdat)    /* Bester Zug    */
  1192. X            dat->bzug=best_so_far;
  1193. X
  1194. X    dat->bzug = dat->zlist[best];        /* besten Zug eintragen    */
  1195. X
  1196. #ifdef    ANALYSE        /* Monitorfunktion: einfache Analyse    */
  1197. X    if(mode & 128)    /* einfache Analyse ?    */
  1198. X    {
  1199. X        bzug[i=0]=dat->bzug;            /* merken    */
  1200. X        while(bzugliste[best][++i]!=(WORD)0)
  1201. X            bzug[i]=bzugliste[best][i];    /* kopieren    */
  1202. X        bzug[i]=(WORD)0;            /* beenden    */
  1203. X    }
  1204. #endif
  1205. X
  1206. X    return(maxwert);            /* beste Bewertung    */
  1207. }
  1208. X
  1209. #ifdef    ANALYSE
  1210. static void monitor(dat,wert,text)
  1211. X
  1212. SPDAT     *dat;
  1213. long    wert;
  1214. char    *text;
  1215. {
  1216. X    SPDAT     *ptr;        /* vorheriger Datensatz    */
  1217. X    int     i=0;          /* Zaehler        */
  1218. X    SPDAT    *ptrlist[20];    /* Liste mit allen Pointern    */
  1219. X    char    str[STRLEN];    /* String        */
  1220. X
  1221. X    ptr=dat;        /* letzte Daten        */
  1222. X    str[0]=0;        /* loeschen        */
  1223. X
  1224. X    while(ptr->vorher != (SPDAT *)0) /* zum Anf.    */
  1225. X    {
  1226. X        ptrlist[i++]=ptr;
  1227. X        ptr= ptr->vorher;
  1228. X    }
  1229. X
  1230. X    while(--i>=0)        /* String erstellen    */
  1231. X    {
  1232. X        sprintf(str+strlen(str),"%s%c",
  1233. X        wandle(_apos(ptrlist[i]->lzug),(BYTE)0),
  1234. X        _istlee(ptrlist[i]->vorher->
  1235. X        brett[_npos(ptrlist[i]->lzug)]) ? '-':'x');
  1236. X
  1237. X        sprintf(str+strlen(str),"%s ",
  1238. X        wandle(_npos(ptrlist[i]->lzug),(BYTE)0));
  1239. X    }
  1240. X
  1241. puts(str);
  1242. X    printf(/*str+strlen(str),*/" %ld %s",wert,text);
  1243. puts("");
  1244. X    /*ANALYSE(str);        /* ausgeben        */
  1245. }
  1246. #endif
  1247. SHAR_EOF
  1248. chmod 0644 ch/comp.c ||
  1249. echo 'restore of ch/comp.c failed'
  1250. Wc_c="`wc -c < 'ch/comp.c'`"
  1251. test 7250 -eq "$Wc_c" ||
  1252.     echo 'ch/comp.c: original size 7250, current size' "$Wc_c"
  1253. rm -f _shar_wnt_.tmp
  1254. fi
  1255. # ============= ch/utility.c ==============
  1256. if test -f 'ch/utility.c' -a X"$1" != X"-c"; then
  1257.     echo 'x - skipping ch/utility.c (File already exists)'
  1258.     rm -f _shar_wnt_.tmp
  1259. else
  1260. > _shar_wnt_.tmp
  1261. echo 'x - extracting ch/utility.c (Text)'
  1262. sed 's/^X//' << 'SHAR_EOF' > 'ch/utility.c' &&
  1263. /****************************************************************/
  1264. /*                                */
  1265. /*    XChess V2.7: Utilities                    */
  1266. /*                                */
  1267. /*    (c) 1991 by Marc Laukien                */
  1268. /*                                */
  1269. /****************************************************************/
  1270. X
  1271. #include <string.h>
  1272. #include <stdio.h>
  1273. #include <ctype.h>
  1274. #include "ch.h"            /* Def. des Schachspiels */
  1275. X
  1276. /****************************************************************/
  1277. /*    Brett ausgeben                        */
  1278. /****************************************************************/
  1279. X
  1280. void    brett_aus(dat,ret)
  1281. X
  1282. SPDAT    *dat;                    /* Spieldaten    */
  1283. char    *ret[];                    /* Antworten    */
  1284. {
  1285. X    BYTE        i,j;            /* Zaehler     */
  1286. X    BYTE        fig;            /* Figur    */
  1287. X    char        c;            /* Zeichen fuer Figur    */
  1288. X    char         str[STRLEN];        /* String fuer Figur    */
  1289. X    static     char    figtab[]=".bbslttdkk";
  1290. X                        /* Figurtabelle    */
  1291. X
  1292. X    for(j=7;j!=0xff;j--)            /* ausgeben    */
  1293. X    {
  1294. X        ret[zaehler][0]=0;        /* beenden    */
  1295. X
  1296. X        for(i=0;i<8;i++)
  1297. X        {
  1298. X            fig=dat->brett[(j+RAND)*ZLEN+i+RAND];
  1299. X            c=figtab[fig&(~(SCH | WEI))];    /* Figur o. Farbe */
  1300. X
  1301. X            if(_istsch(fig))
  1302. X                c += 'A'-'a';    /* gross machen    */
  1303. X
  1304. X            sprintf(str,"%c ",c);    /* Antwort herstellen    */
  1305. X            strcat(ret[zaehler],str);
  1306. X        }
  1307. X
  1308. X        zaehler++;
  1309. X    }
  1310. }
  1311. X
  1312. /****************************************************************/
  1313. /*    Informationen ausgeben                    */
  1314. /****************************************************************/
  1315. X
  1316. void    info_aus(dat,ret)
  1317. X
  1318. SPDAT    *dat;                    /* Spieldaten    */
  1319. char    *ret[];                    /* Antworten    */
  1320. {
  1321. X    SPDAT datc;                /* Spieldaten    */
  1322. X
  1323. X    eff_stufe(dat);                /* Stufe einstellen    */
  1324. X    sprintf(ret[zaehler++],
  1325. X
  1326. X    "%c",dat->farbe==WEI?'w':'s');        /* Farbe am Zug        */
  1327. X
  1328. X    sprintf(ret[zaehler++],
  1329. X    "%d",dat->zuege);            /* Anz. der Zuege    */
  1330. X
  1331. X    sprintf(ret[zaehler++],            /* Bewertung        */
  1332. X    "%ld",bewerte(dat,(BYTE)0));
  1333. X
  1334. X    sprintf(ret[zaehler++],"%ld",varianten);    /* Anz. d. Var.    */
  1335. X
  1336. X    sprintf(ret[zaehler++],"%ld",            /* Var. / Sek.    */
  1337. X    varianten/((long)zeit>0 ? (long)zeit:1L));
  1338. X
  1339. X    sprintf(ret[zaehler++],"%ld",            /* Var. / Sek.    */
  1340. X    varprosek/(long)(compzuege > 0 ?        /* gesamt    */
  1341. X    (compzuege<=50 ? compzuege:50):1));
  1342. X
  1343. X    sprintf(ret[zaehler++],"%d",stufe);        /* Spielstufe    */
  1344. X
  1345. X    sprintf(ret[zaehler++],"%d",dat->minstufe);    /* Rechentiefen    */
  1346. X    sprintf(ret[zaehler++],"%d",dat->maxstufe);
  1347. X
  1348. X    sprintf(ret[zaehler++],"%d",mode);        /* Modus    */
  1349. X
  1350. X    if(!hole_zurueck(&datc,dat->zuege-1))        /* holen    */
  1351. X    {
  1352. X        sprintf(ret[zaehler++],"%s",        /* letzter Zug    */
  1353. X        wandle(_apos(dat->lzug),_npos(dat->lzug)));
  1354. X    }
  1355. X    else
  1356. X    {
  1357. X        WORD komb[2];                /* Kombination    */
  1358. X
  1359. X        komb[0]=dat->lzug;            /* eintragen    */
  1360. X        komb[1]=(WORD)0;            /* beenden    */
  1361. X
  1362. X        sprintf(ret[zaehler++],"%s",        /* letzter Zug    */
  1363. X        kombination(&datc,komb));        /* ausgeben    */
  1364. X    }
  1365. }
  1366. X
  1367. /****************************************************************/
  1368. /*    Zugliste ausgeben                    */
  1369. /****************************************************************/
  1370. X
  1371. void    zugliste_aus(dat,modus,ret)
  1372. X
  1373. SPDAT    *dat;                    /* Spieldaten    */
  1374. int    modus;                    /* 1: +Bew.    */
  1375. char    *ret[];                    /* Antworten    */
  1376. {
  1377. X    int    i= -1;                /* Zaehler     */
  1378. X
  1379. X    while(dat->zlist[++i])            /* alle Zuege durch    */
  1380. X    if(modus)                /* mit Bewertung    */
  1381. X        sprintf(ret[zaehler++],"%s = %ld",
  1382. X        wandle(_apos(dat->zlist[i]),_npos(dat->zlist[i])),
  1383. X        dat->blist[i]);
  1384. X                        /* kopieren    */
  1385. X    else                    /* ohne Bewertung    */
  1386. X        sprintf(ret[zaehler++],"%s",
  1387. X        wandle(_apos(dat->zlist[i]),_npos(dat->zlist[i])));
  1388. X                        /* kopieren    */
  1389. X
  1390. X    sprintf(ret[zaehler++],"(%d)",i);
  1391. }
  1392. X
  1393. /****************************************************************/
  1394. /*    Zug/Positionsangabe umwandeln                */
  1395. /****************************************************************/
  1396. /*    Falls posa == 0 : Positionsstring            */
  1397. /****************************************************************/
  1398. X
  1399. char *wandle(posa,posn)
  1400. X
  1401. BYTE    posa,posn;                /* Positionen        */
  1402. {
  1403. X    static     char     str[STRLEN];        /* String mit Pos/Zug     */
  1404. X    BYTE        xposa,yposa;        /* Koordinaten    alt     */
  1405. X    BYTE        xposn,yposn;        /* Koordinaten    neu     */
  1406. X
  1407. X    if(posa==(BYTE)0 && posn==(BYTE)0)    /* Kein Zug ?        */
  1408. X        return("----");
  1409. X
  1410. X    xposa=_xpos(posa);            /* alte Koordinaten holen */
  1411. X    yposa=_ypos(posa);
  1412. X
  1413. X    if(posn!=(BYTE)0)
  1414. X    {
  1415. X        xposn=_xpos(posn);        /* neue Koordinaten holen */
  1416. X        yposn=_ypos(posn);
  1417. X
  1418. X        sprintf(str,"%c%c%c%c",        /* aufbereiten    */
  1419. X        xposa+'a',yposa+'1',
  1420. X        xposn+'a',yposn+'1');
  1421. X    }
  1422. X    else
  1423. X        sprintf(str,"%c%c",        /* aufbereiten    */
  1424. X        xposa+'a',yposa+'1');
  1425. X
  1426. X    return(str);
  1427. }
  1428. X
  1429. /****************************************************************/
  1430. /*    Zug/Positionsangabe inveres umwandeln            */
  1431. /****************************************************************/
  1432. /*    Return: Zug/Position oder 0 bei Fehler            */
  1433. /****************************************************************/
  1434. X
  1435. WORD wandle_inv(str)
  1436. X
  1437. char     *str;                /* String mit Zug/Position    */
  1438. {
  1439. X    WORD    zug=0;            /* Zug/Position    */
  1440. X    int     i,j;            /* Zaehler    */
  1441. X    char    c;            /* aktuelles Zeichen in str    */
  1442. X    WORD    teil[4];        /* Teile des Zugs    */
  1443. X
  1444. X    for(i=0,j=0;str[i] != 0;i++)    /* String durchgehen        */
  1445. X    {
  1446. X        c=str[i];
  1447. X
  1448. X        if(c==' ' || c=='-' || c=='x' || c=='_' || c=='+')
  1449. X            continue;
  1450. X        else switch(j)
  1451. X        {
  1452. X        case 0:
  1453. X        case 2:
  1454. X            if(c>='a' && c<='h')
  1455. X                teil[j++] = c-'a';
  1456. X            else if(c>='A' && c<='H')
  1457. X                teil[j++] = c-'A';
  1458. X            else
  1459. X                return((WORD)0);    /* Fehler    */
  1460. X            break;
  1461. X
  1462. X        case 1:
  1463. X        case 3:
  1464. X            if(c>='1' && c<='8')
  1465. X                teil[j++] = c-'1';
  1466. X            else
  1467. X                return((WORD)0);    /* Fehler    */
  1468. X            break;
  1469. X
  1470. X        default:
  1471. X            return((WORD)0);    /* Fehler    */
  1472. X        }
  1473. X    }
  1474. X
  1475. X    if(j==2 || j==4)            /* korrekt ?    */
  1476. X        zug |= teil[0]+RAND+(8+2*RAND)*(RAND+teil[1]);
  1477. X
  1478. X    if(j==4)                /* korrekt ?    */
  1479. X        zug |= (teil[2]+RAND+(8+2*RAND)*(RAND+teil[3])) << 8;
  1480. X
  1481. X    return(zug);
  1482. }
  1483. X
  1484. /****************************************************************/
  1485. /*    Figur in internes Format                */
  1486. /****************************************************************/
  1487. /*    Return: Figur oder 0 bei Fehler             */
  1488. /****************************************************************/
  1489. X
  1490. BYTE wandle_fig(c)
  1491. X
  1492. char c;                    /* Figur    */
  1493. {
  1494. X    char c2;
  1495. X    BYTE fig;            /* internes Format    */
  1496. X
  1497. X    c2=c;
  1498. X    if(isupper(c))                /* klein machen    */
  1499. X        c2=tolower(c);
  1500. X
  1501. X    switch(c2)            /* umwandeln    */
  1502. X    {
  1503. X    case 'b':
  1504. X        fig=BAU;
  1505. X        break;
  1506. X
  1507. X    case 's':
  1508. X        fig=SPR;
  1509. X        break;
  1510. X
  1511. X    case 'l':
  1512. X        fig=LAE;
  1513. X        break;
  1514. X
  1515. X    case 't':
  1516. X        fig=TUR;
  1517. X        break;
  1518. X
  1519. X    case 'd':
  1520. X        fig=DAM;
  1521. X        break;
  1522. X
  1523. X    case 'k':
  1524. X        fig=KOE;
  1525. X        break;
  1526. X
  1527. X    case '.':
  1528. X        fig=LEE;
  1529. X        break;
  1530. X
  1531. X    default:
  1532. X         return(0);            /* Fehler    */
  1533. X    }
  1534. X
  1535. X    if(isupper(c))
  1536. X        fig|=SCH;
  1537. X    else
  1538. X        fig|=WEI;
  1539. X
  1540. X    return(fig);
  1541. }
  1542. X
  1543. /****************************************************************/
  1544. /*    Kombination erstellen                    */
  1545. /****************************************************************/
  1546. /*    Return:    Kombinationsstring                */
  1547. /****************************************************************/
  1548. X
  1549. char *kombination(dat,zugkomb)
  1550. X
  1551. SPDAT     *dat;                    /* Spieldaten        */
  1552. WORD    zugkomb[];                /* Zugkombination     */
  1553. {
  1554. X    SPDAT        copy;            /* Kopie der Spieldaten    */
  1555. X    SPDAT        *cdat;            /* Zeiger auf Kopie    */
  1556. X    WORD        zug;
  1557. X    static char    str[STRLEN];        /* String        */
  1558. X    int        i;
  1559. X
  1560. X    str[0]=0;                /* loeschen        */
  1561. X
  1562. X    cdat= ©                /* Zeiger bestimmen    */
  1563. X
  1564. X    if(dat == (SPDAT *)0)
  1565. X        init(cdat,1);
  1566. X    else
  1567. X    {
  1568. X        for(i=0;i<GROE;i++)        /* kopieren        */
  1569. X            cdat->brett[i]=dat->brett[i];
  1570. X
  1571. X        cdat->wkpos    = dat->wkpos;
  1572. X        cdat->skpos    = dat->skpos;
  1573. X        cdat->farbe    = dat->farbe;
  1574. X        cdat->lzug      = dat->lzug;
  1575. X        cdat->zuege    = dat->zuege;
  1576. X    }
  1577. X
  1578. X    i=0;
  1579. X    while((zug=zugkomb[i])!=(WORD)0 && i<MAXTIEFE)    
  1580. X                        /* Ende ?        */
  1581. X    {
  1582. X        cdat->minstufe=spdat.minstufe;    /* damit Koenigsbedro.    */
  1583. X        cdat->maxstufe=spdat.maxstufe;    /* ueberprueft wird    */
  1584. X
  1585. X        if(!zug_test(cdat,zugkomb[i]))    /* illegaler Zug ?    */
  1586. X            break;
  1587. X
  1588. X        sprintf(str+strlen(str),"%s%c",    /* String aufbereiten    */
  1589. X        wandle(_apos(zug),(BYTE)0),
  1590. X        _istlee(cdat->brett[_npos(zug)]) ? '-':'x');
  1591. X
  1592. X        sprintf(str+strlen(str),"%s",
  1593. X        wandle(_npos(zug),(BYTE)0));
  1594. X
  1595. X        ziehe(cdat,zugkomb[i++]);    /* ziehen        */
  1596. X
  1597. X        if(cdat->farbe==WEI)
  1598. X            if(bedrohung(cdat,cdat->wkpos))
  1599. X                strcat(str,"+");/* wei. Koenig bedroht    */
  1600. X
  1601. X        if(cdat->farbe==SCH)
  1602. X            if(bedrohung(cdat,cdat->skpos))
  1603. X                strcat(str,"+");/* schw. Koenig bedroht    */
  1604. X
  1605. X        strcat(str," ");        /* Trennzeichen        */
  1606. X    }
  1607. X
  1608. X    str[strlen(str)-1]=0;            /* beenden        */
  1609. X
  1610. X    return(str);
  1611. }
  1612. SHAR_EOF
  1613. chmod 0644 ch/utility.c ||
  1614. echo 'restore of ch/utility.c failed'
  1615. Wc_c="`wc -c < 'ch/utility.c'`"
  1616. test 7922 -eq "$Wc_c" ||
  1617.     echo 'ch/utility.c: original size 7922, current size' "$Wc_c"
  1618. rm -f _shar_wnt_.tmp
  1619. fi
  1620. # ============= ch/threat.c ==============
  1621. if test -f 'ch/threat.c' -a X"$1" != X"-c"; then
  1622.     echo 'x - skipping ch/threat.c (File already exists)'
  1623.     rm -f _shar_wnt_.tmp
  1624. else
  1625. > _shar_wnt_.tmp
  1626. echo 'x - extracting ch/threat.c (Text)'
  1627. sed 's/^X//' << 'SHAR_EOF' > 'ch/threat.c' &&
  1628. /****************************************************************/
  1629. /*                                */
  1630. /*    XChess V2.7: Bedrohung testen                */
  1631. /*                                */
  1632. /*    (c) 1991 by Marc Laukien                */
  1633. /*                                */
  1634. /****************************************************************/
  1635. X
  1636. #include "ch.h"            /* Def. des Schachspiels */
  1637. X
  1638. /****************************************************************/
  1639. /*    Feld auf Bedrohung testen                */
  1640. /*    Testet nicht auf e.p.                    */
  1641. /****************************************************************/
  1642. /*    Return:    1: bedroht    0: nicht bedroht        */
  1643. /****************************************************************/
  1644. X
  1645. int    bedrohung(dat,pos)
  1646. X
  1647. SPDAT    *dat;                /* Spieldaten    */
  1648. BYTE    pos;                /* Position    */
  1649. {
  1650. X    static short wbed[][12] =    /* Bedrohung durch Weiss    */
  1651. X    {
  1652. X        /* Bedrohung durch Bauer */
  1653. X        {-11,-13,0},
  1654. X        /* Bedrohung durch Springer    */
  1655. X        {14,25,23,10,-14,-25,-23,-10,0},
  1656. X        /* Bedrohung durch Laeufer Dame und Koenig    */
  1657. X        {13,11,-13,-11,0},
  1658. X        /* Bedrohung durch Turm, Dame und Koenig    */
  1659. X        {1,12,-1,-12,0},
  1660. X    };
  1661. X
  1662. X    static short sbed[][12] =    /* Bedrohung durch Schwarz    */
  1663. X    {
  1664. X        /* Bedrohung durch Bauer */
  1665. X        {11,13,0},
  1666. X        /* Bedrohung durch Springer    */
  1667. X        {14,25,23,10,-14,-25,-23,-10,0},
  1668. X        /* Bedrohung durch Laeufer Dame und Koenig    */
  1669. X        {13,11,-13,-11,0},
  1670. X        /* Bedrohung durch Turm, Dame und Koenig    */
  1671. X        {1,12,-1,-12,0},
  1672. X    };
  1673. X
  1674. X    register short    (*bed)[12];    /* effektive Bedrohungsliste    */
  1675. X    register BYTE    k;        /* Zaehler            */
  1676. X    register BYTE    pos2;        /* Position des Bedrohers    */
  1677. X    register short    zug;        /* aktueller Zug        */
  1678. X    register BYTE    fa;        /* Farbe            */
  1679. X
  1680. X    if(_istlee(dat->brett[pos]))       /* Farbe bestimmen    */
  1681. X        fa=dat->farbe;
  1682. X    else
  1683. X        fa=_farbe(dat->brett[pos]);
  1684. X
  1685. X    if(fa==WEI)            /* eff. Bedrl. best.*/
  1686. X        bed=sbed;
  1687. X    else
  1688. X        bed=wbed;
  1689. X
  1690. X    for(k=0;zug=bed[2][k];k++)    /* LAEUFER, DAME, KOENIG    */
  1691. X                    /* alle Zuege durchg.        */
  1692. X    {
  1693. X        pos2=(BYTE)((short)pos+zug);
  1694. X
  1695. X        if(_istkoe(dat->brett[pos2]) && fa!=_farbe(dat->brett[pos2]))
  1696. X            return(1);    /* Bedrohung gefunden    */
  1697. X
  1698. X        while(_istlee(dat->brett[pos2]))    /* suchen    */
  1699. X            pos2= (BYTE)((short)pos2+zug);
  1700. X
  1701. X        if((_istlae(dat->brett[pos2]) ||
  1702. X            _istdam(dat->brett[pos2])) &&
  1703. X             fa!=_farbe(dat->brett[pos2]))
  1704. X                return(1);    /* Bedrohung gefunden    */
  1705. X    }
  1706. X
  1707. X    for(k=0;zug=bed[3][k];k++)    /* TURM, DAME, KOENIG    */
  1708. X                    /* alle Zuege durchg.    */
  1709. X    {
  1710. X        pos2=(BYTE)((short)pos+zug);
  1711. X
  1712. X        if(_istkoe(dat->brett[pos2]) && fa!=_farbe(dat->brett[pos2]))
  1713. X            return(1);    /* Bedrohung gefunden    */
  1714. X
  1715. X        while(_istlee(dat->brett[pos2]))    /* suchen    */
  1716. X            pos2= (BYTE)((short)pos2+zug);
  1717. X
  1718. X        if((_isttur(dat->brett[pos2]) ||
  1719. X            _istdam(dat->brett[pos2])) &&
  1720. X             fa!=_farbe(dat->brett[pos2]))
  1721. X                return(1);    /* Bedrohung gefunden    */
  1722. X    }
  1723. X
  1724. X    for(k=0;zug=bed[0][k];k++)    /* BAUER        */
  1725. X                    /* alle Zuege durchg.    */
  1726. X    {
  1727. X        pos2=(BYTE)((short)pos+zug);
  1728. X        if(_istbau(dat->brett[pos2]) && fa!=_farbe(dat->brett[pos2]))
  1729. X            return(1);    /* Bedrohung gefunden    */
  1730. X    }
  1731. X
  1732. X    for(k=0;zug=bed[1][k];k++)    /* SPRINGER        */
  1733. X                    /* alle Zuege durchg.    */
  1734. X    {
  1735. X        pos2=(BYTE)((short)pos+zug);
  1736. X        if(_istspr(dat->brett[pos2]) && fa!=_farbe(dat->brett[pos2]))
  1737. X            return(1);    /* Bedrohung gefunden    */
  1738. X    }
  1739. X
  1740. X    return(0);            /* keine Bedrohung gefunden    */
  1741. }
  1742. SHAR_EOF
  1743. chmod 0644 ch/threat.c ||
  1744. echo 'restore of ch/threat.c failed'
  1745. Wc_c="`wc -c < 'ch/threat.c'`"
  1746. test 3106 -eq "$Wc_c" ||
  1747.     echo 'ch/threat.c: original size 3106, current size' "$Wc_c"
  1748. rm -f _shar_wnt_.tmp
  1749. fi
  1750. # ============= ch/init.c ==============
  1751. if test -f 'ch/init.c' -a X"$1" != X"-c"; then
  1752.     echo 'x - skipping ch/init.c (File already exists)'
  1753.     rm -f _shar_wnt_.tmp
  1754. else
  1755. > _shar_wnt_.tmp
  1756. echo 'x - extracting ch/init.c (Text)'
  1757. sed 's/^X//' << 'SHAR_EOF' > 'ch/init.c' &&
  1758. /****************************************************************/
  1759. /*                                */
  1760. /*    XChess V2.7: Initialisierungen                */
  1761. /*                                */
  1762. /*    (c) 1991 by Marc Laukien                */
  1763. /*                                */
  1764. /****************************************************************/
  1765. X
  1766. #include "ch.h"            /* Def. des Schachspiels */
  1767. #include <string.h>
  1768. #include <stdio.h>          /* Standart IO */
  1769. X
  1770. extern    long    time();
  1771. extern    void    exit();
  1772. extern    char    *malloc();
  1773. extern    char    *memcpy();
  1774. extern    void    free();
  1775. extern    void    srand();
  1776. X
  1777. /****************************************************************/
  1778. /*    Initialisierungen                    */
  1779. /****************************************************************/
  1780. X
  1781. void    init(dat,modus)
  1782. X
  1783. SPDAT     *dat;        /* Spieldaten    */
  1784. int    modus;        /* 1=initialisieren, sonst nur loeschen    */
  1785. {
  1786. X    static     first=1;
  1787. X    BYTE    i,j;        /* Zaehler     */
  1788. X
  1789. X    static BYTE initbrett[8][8] =
  1790. X    {
  1791. XXTUR+WEI,SPR +WEI,LAE +WEI,DAM +WEI,XKOE+WEI,LAE +WEI,SPR +WEI,XTUR+WEI,
  1792. XXBAU+WEI,XBAU+WEI,XBAU+WEI,XBAU+WEI,XBAU+WEI,XBAU+WEI,XBAU+WEI,XBAU+WEI,
  1793. LEE     ,LEE     ,LEE     ,LEE     ,LEE     ,LEE     ,LEE     ,LEE     ,
  1794. LEE     ,LEE     ,LEE     ,LEE     ,LEE     ,LEE     ,LEE     ,LEE     ,
  1795. LEE     ,LEE     ,LEE     ,LEE     ,LEE     ,LEE     ,LEE     ,LEE     ,
  1796. LEE     ,LEE     ,LEE     ,LEE     ,LEE     ,LEE     ,LEE     ,LEE     ,
  1797. XXBAU+SCH,XBAU+SCH,XBAU+SCH,XBAU+SCH,XBAU+SCH,XBAU+SCH,XBAU+SCH,XBAU+SCH,
  1798. XXTUR+SCH,SPR +SCH,LAE +SCH,DAM +SCH,XKOE+SCH,LAE +SCH,SPR +SCH,XTUR+SCH,
  1799. X    };
  1800. X
  1801. X    if(first)        /* nur einmal ausfuehren    */
  1802. X    {
  1803. X        srand((unsigned)time((long *)0));
  1804. X                    /* Zufallsgenerator    */
  1805. X        for(i=0;i<MAXSP;i++)    /* loeschen        */
  1806. X            archiv[i]=(ARCHIV *)0;
  1807. X
  1808. X        load_open();        /* Eroeffnungen laden    */
  1809. X        first=0;
  1810. X    }
  1811. X
  1812. X    for(i=0;i<GROE;i++)    /* Brett mit Spezialfiguren besetzen */
  1813. X        dat->brett[i]=SPZ;
  1814. X
  1815. X    if(modus==1)            /* Initialisieren ?    */
  1816. X    {
  1817. X        for(j=0;j<8;j++)        /* aufbauen    */
  1818. X            for(i=0;i<8;i++)
  1819. X                dat->brett[(j+RAND)*(8+2*RAND)+i+RAND]=
  1820. X                initbrett[j][i];
  1821. X
  1822. X        dat->wkpos=2*ZLEN+RAND+4;    /* Koenigspsoitionen    */
  1823. X        dat->skpos=(2+7)*ZLEN+RAND+4;
  1824. X    }
  1825. X    else                    /* Brett loeschen    */
  1826. X    {
  1827. X        for(j=0;j<8;j++)
  1828. X            for(i=0;i<8;i++)
  1829. X                dat->brett[(j+RAND)*(8+2*RAND)+i+RAND]=LEE;
  1830. X
  1831. X        noop=0;        /* Bib. schliessen    */
  1832. X
  1833. X        dat->wkpos=(BYTE)0;    /* Koenigspsoitionen    */
  1834. X        dat->skpos=(BYTE)0;
  1835. X    }
  1836. X
  1837. X    dat->farbe     =WEI;            /* Weiss beginnt    */
  1838. X    dat->lzug      =(WORD)0;        /* letzter Zug        */
  1839. X    dat->zuege    =0;            /* Kein Zug bis jetzt    */
  1840. X    dat->wert    =bewerte(dat,(BYTE)0);    /* Bewerten        */
  1841. X    dat->vorher    =(SPDAT *)0;        /* kein Datensatz davor    */
  1842. X
  1843. X    if(dat==&spdat)
  1844. X    {
  1845. X        varprosek=0L;            /* Varianten pro Sekunde*/
  1846. X        varianten=0L;            /* Varianten gesamt    */
  1847. X        zeit=0L;            /* Rechenzeit        */
  1848. X        compzuege=0;            /* Computerzuege    */
  1849. X        noop=OPTRYS;            /* Eroeffnungen zulassen*/
  1850. X
  1851. X        for(i=0;i<MAXSP;i++)        /* Speicher freigeben    */
  1852. X            if(archiv[i]!=(ARCHIV *)0)
  1853. X            {
  1854. X                free(archiv[i]);
  1855. X                archiv[i]=(ARCHIV *)0;
  1856. X            }
  1857. X
  1858. X        archiviere(&spdat);        /* archivieren         */
  1859. X    }
  1860. }
  1861. X
  1862. /************************************************************************/
  1863. /*      Eroeffnungen laden                                              */
  1864. /************************************************************************/
  1865. X
  1866. void    load_open()
  1867. X
  1868. {
  1869. X    FILE     *fp;                  /* Filepointer         */
  1870. X    char     str[200*5];             /* String zum einlesen    */
  1871. X    char    str2[5];        /* String mit einem Zug    */
  1872. X    WORD    open[200];        /* Array mit Eroeffnung    */
  1873. X    BYTE    farbe;    /* Farbe fuer die die Eroeffnung gilt    */
  1874. X    int i,j;
  1875. X
  1876. X    if((fp=fopen("chess.op","r"))==(FILE *)0)         /* oeffnen    */
  1877. X        exit(1);                                /* Fehler     */
  1878. X
  1879. X    opnr=0;                         /* noch keine Eroeffnung     */
  1880. X
  1881. X    while(feof(fp)==0 && opnr < MAXOP)        /* Ende ?    */
  1882. X        {
  1883. X        fgets(str,999,fp);      /* einlesen     */
  1884. X
  1885. X                i=0;
  1886. X        while(str[i]!='#' && str[i]!='\n' && str[i]!=0)
  1887. X            i++;
  1888. X
  1889. X        str[i]=0;               /* beenden     */
  1890. X
  1891. X        if(!strlen(str))    /* Leerzeile  ?    */
  1892. X            continue;
  1893. X
  1894. X        farbe=(BYTE)0;
  1895. X
  1896. X        i=0;j=0;
  1897. X        while(i<strlen(str))
  1898. X                {
  1899. X            if(str[i]==' ' || str[i]==TAB || str[i]==';'
  1900. X            || str[i]==',' || str[i]=='.' || str[i]==':')
  1901. X            {
  1902. X                i++;
  1903. X                continue;
  1904. X            }
  1905. X
  1906. X            if(str[i]=='W')        /* Komb. fuer Weiss ?    */
  1907. SHAR_EOF
  1908. true || echo 'restore of ch/init.c failed'
  1909. fi
  1910. echo 'End of UnixChess part 1'
  1911. echo 'File ch/init.c is continued in part 2'
  1912. echo 2 > _shar_seq_.tmp
  1913. exit 0
  1914. -- 
  1915.    /              |    -: Marc Laukien :-     |
  1916.   /__             |                           |   _  _           __
  1917.  /   \  /_  /  /  |   ml@brumuc.muc.sub.org   |  / \/ |   /  /  /
  1918. /____/ /   /__/   | sigma@salyko.doit.sub.org | /     |  /__/  /__
  1919.