home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 3 / 3381 < prev    next >
Encoding:
Internet Message Format  |  1991-05-21  |  49.9 KB
  1. From: ml@brumuc.muc.sub.org (Marc Laukien)
  2. Newsgroups: alt.sources
  3. Subject: UnixChess02/10
  4. Message-ID: <1991May20.003104.6236@brumuc.muc.sub.org>
  5. Date: 20 May 91 00:31:04 GMT
  6.  
  7. Submitted-by: ml@brumuc.muc.sub.org
  8. Archive-name: UnixChess/part02
  9.  
  10. ---- Cut Here and feed the following to sh ----
  11. #!/bin/sh
  12. # this is chess.02 (part 2 of UnixChess)
  13. # do not concatenate these parts, unpack them in order with /bin/sh
  14. # file ch/init.c continued
  15. #
  16. if test ! -r _shar_seq_.tmp; then
  17.     echo 'Please unpack part 1 first!'
  18.     exit 1
  19. fi
  20. (read Scheck
  21.  if test "$Scheck" != 2; then
  22.     echo Please unpack part "$Scheck" next!
  23.     exit 1
  24.  else
  25.     exit 0
  26.  fi
  27. ) < _shar_seq_.tmp || exit 1
  28. if test ! -f _shar_wnt_.tmp; then
  29.     echo 'x - still skipping ch/init.c'
  30. else
  31. echo 'x - continuing file ch/init.c'
  32. sed 's/^X//' << 'SHAR_EOF' >> 'ch/init.c' &&
  33. X            {
  34. X                farbe |= WEI;
  35. X                i++;
  36. X                continue;
  37. X            }
  38. X
  39. X            if(str[i]=='B')        /* Komb. fuer Schwarz ?    */
  40. X            {
  41. X                farbe |= SCH;
  42. X                i++;
  43. X                continue;
  44. X            }
  45. X
  46. X            strncpy(str2,str+i,4);        /* Zug holen    */
  47. X            str2[4]=0;            /* beenden    */
  48. X
  49. X            open[j]=wandle_inv(str2);    /* umwandeln    */
  50. X            if(open[j]==(WORD)0)          /* Fehler ?     */
  51. X                        open[j]=wandle_inv("a1a1");
  52. X                        /* unmoeglicher Zug    */
  53. X
  54. X            j++;
  55. X            i += 4;            /* naechster Zug    */
  56. X        }
  57. X
  58. X        open[j]=(WORD)0;            /* beenden    */
  59. X
  60. X        op[opnr]=(WORD *)malloc((unsigned)sizeof(WORD)*(j+1));
  61. X        if(op[opnr]==(WORD *)0)        /* Fataler Fehler    */
  62. X            exit(1);
  63. X
  64. X        op_fa[opnr]=farbe;
  65. X        memcpy((char *)op[opnr++],(char *)open,
  66. X        (int)sizeof(WORD)*(j+1));/* kopieren    */
  67. X    }
  68. X
  69. X    fclose(fp);                               /* schliessen     */
  70. X
  71. X    for(i=opnr;i<MAXOP;i++)                /* loeschen    */
  72. X        op[i]=(WORD *)0;
  73. }
  74. SHAR_EOF
  75. echo 'File ch/init.c is complete' &&
  76. chmod 0644 ch/init.c ||
  77. echo 'restore of ch/init.c failed'
  78. Wc_c="`wc -c < 'ch/init.c'`"
  79. test 4881 -eq "$Wc_c" ||
  80.     echo 'ch/init.c: original size 4881, current size' "$Wc_c"
  81. rm -f _shar_wnt_.tmp
  82. fi
  83. # ============= ch/list.c ==============
  84. if test -f 'ch/list.c' -a X"$1" != X"-c"; then
  85.     echo 'x - skipping ch/list.c (File already exists)'
  86.     rm -f _shar_wnt_.tmp
  87. else
  88. > _shar_wnt_.tmp
  89. echo 'x - extracting ch/list.c (Text)'
  90. sed 's/^X//' << 'SHAR_EOF' > 'ch/list.c' &&
  91. /****************************************************************/
  92. /*                                */
  93. /*    XChess V2.7: Zugliste                    */
  94. /*                                */
  95. /*    (c) 1991 by Marc Laukien                */
  96. /*                                */
  97. /****************************************************************/
  98. X
  99. #include "ch.h"            /* Def. des Schachspiels */
  100. X
  101. static void add();
  102. static void zugliste2();
  103. X
  104. /****************************************************************/
  105. /*    Zugliste erstellen                    */
  106. /****************************************************************/
  107. /*    Return:    Anzahl der Zuege                */
  108. /****************************************************************/
  109. X
  110. int    zugliste(dat,pos)
  111. X
  112. SPDAT    *dat;                /* Spieldaten    */
  113. BYTE    pos;                /* Position    */
  114. {
  115. X    int     nr=0;            /* Anzahl der Zuege    */
  116. X    register int    i,j;        /* Zaehler        */
  117. X
  118. X    dat->zlist[0]=0;        /* loeschen            */
  119. X
  120. X    if(pos)                          /* nur ein Feld ?        */
  121. X        zugliste2(dat,pos,&nr);
  122. X    else
  123. X    {
  124. X        if(dat->farbe==SCH)    /* Schwarz von unten nach oben    */
  125. X        for(j=0;j<8;j++)    /* alle Felder durchgehen    */
  126. X        for(i=0;i<8;i++)
  127. X            if(!_istlee(dat->brett[pos=
  128. X            (BYTE)((j+RAND)*ZLEN+i+RAND)]))
  129. X                zugliste2(dat,pos,&nr);
  130. X
  131. X        if(dat->farbe==WEI)    /* Weiss von oben nach unten    */
  132. X        for(j=7;j>=0;j--)    /* alle Felder durchgehen    */
  133. X        for(i=0;i<8;i++)
  134. X            if(!_istlee(dat->brett[pos=
  135. X            (BYTE)((j+RAND)*ZLEN+i+RAND)]))
  136. X                zugliste2(dat,pos,&nr);
  137. X    }
  138. X
  139. X    return(nr);
  140. }
  141. X
  142. static    void    zugliste2(dat,posa,nr)
  143. X
  144. SPDAT        *dat;            /* Spieldaten        */
  145. register BYTE    posa;            /* alte Position    */
  146. int         *nr;                /* Zugzaehler        */
  147. {
  148. X    static short wzuege[][12] =    /* Weisse Zuege        */
  149. X    {
  150. X        {0,0},
  151. X        /* Bauerzuege        */
  152. X        {2,11,13,12,0},
  153. X        /* X Bauerzuege     */
  154. X        {2,11,13,12,24,0},
  155. X        /* Springerzuege    */
  156. X        {0,14,25,23,10,-14,-25,-23,-10,0},
  157. X        /* Laeuferzuege     */
  158. X        {1,13,11,-13,-11,0},
  159. X        /* Turmzuege         */
  160. X        {1,1,12,-1,-12,0},
  161. X        /* X Turmzuege         */
  162. X        {1,1,12,-1,-12,0},
  163. X        /* Damenzuege         */
  164. X        {1,1,13,12,11,-1,-13,-12,-11,0},
  165. X        /* Koenigzuege         */
  166. X        {0,1,13,12,11,-1,-13,-12,-11,0},
  167. X        /* X Koenigzuege     */
  168. X        {3,2,-2,1,13,12,11,-1,-13,-12,-11,0}
  169. X    };
  170. X
  171. X    static short szuege[][12] =    /* Schwarze Zuege    */
  172. X    {
  173. X        {0,0},
  174. X        /* Bauerzuege        */
  175. X        {2,-11,-13,-12,0},
  176. X        /* X Bauerzuege     */
  177. X        {2,-11,-13,-12,-24,0},
  178. X        /* Springerzuege    */
  179. X        {0,14,25,23,10,-14,-25,-23,-10,0},
  180. X        /* Laeuferzuege     */
  181. X        {1,13,11,-13,-11,0},
  182. X        /* Turmzuege         */
  183. X        {1,1,12,-1,-12,0},
  184. X        /* X Turmzuege         */
  185. X        {1,1,12,-1,-12,0},
  186. X        /* Damenzuege         */
  187. X        {1,1,13,12,11,-1,-13,-12,-11,0},
  188. X        /* Koenigzuege         */
  189. X        {0,1,13,12,11,-1,-13,-12,-11,0},
  190. X        /* X Koenigzuege     */
  191. X        {3,2,-2,1,13,12,11,-1,-13,-12,-11,0}
  192. X    };
  193. X
  194. X    short    (*zuege)[12];        /* effektive Zugliste    */
  195. X
  196. X    /* ^ alle Zuege fuer RAND = 2    */
  197. X
  198. X    register BYTE    fig;            /* Figur        */
  199. X    register BYTE    k;            /* Zaehler        */
  200. X    register BYTE    posn;            /* neue Position    */
  201. X    register short    zug;            /* aktueller Zug    */
  202. X
  203. X    fig=dat->brett[posa];            /* Figur holen    */
  204. X
  205. X    if(_farbe(fig) != dat->farbe)        /* falsche Farbe ? */
  206. X        return;
  207. X
  208. X    if(dat->farbe == WEI)            /* eff. Zugl. best.*/
  209. X        zuege=wzuege;
  210. X    else
  211. X        zuege=szuege;
  212. X
  213. X    switch(zuege[_figur(fig)][0])
  214. X    {
  215. X    case 0:                /* keine Wiederholung    */
  216. X        for(k=1;zug=zuege[_figur(fig)][k];k++)
  217. X                    /* alle Zuege durchg.    */
  218. X        {
  219. X            posn=(BYTE)((short)posa+zug);
  220. X
  221. X            if(!(dat->farbe & _farbe(dat->brett[posn])))
  222. X                add(dat,nr,posa,posn);
  223. X                    /* Zug anhaengen    */
  224. X        }
  225. X        break;
  226. X    case 1:                /* wiederholen        */
  227. X        for(k=1;zug=zuege[_figur(fig)][k];k++)
  228. X                    /* alle Zuege durchg.    */
  229. X        {
  230. X            posn=(BYTE)((short)posa+zug);
  231. X
  232. X            while(_istlee(dat->brett[posn]))
  233. X            {
  234. X                add(dat,nr,posa,posn);
  235. X                    /* Zug anhaengen    */
  236. X                posn= (BYTE)((short)posn+zug);
  237. X            }
  238. X
  239. X            if(!(dat->farbe&_farbe(dat->brett[posn])))
  240. X                add(dat,nr,posa,posn);
  241. X                    /* Zug anhaengen    */
  242. X        }
  243. X        break;
  244. X    case 2:                /* Bauer        */
  245. X        for(k=1;zug=zuege[_figur(fig)][k];k++)
  246. X                    /* alle Zuege durchg.    */
  247. X        {
  248. X            posn=(BYTE)((short)posa+zug);
  249. X            if(k<=2)    /* nur schlagen        */
  250. X            {
  251. X            if(_istlee(dat->brett[posn]))
  252. X            /* Feld leer, schlagen nur e.p. mgl.    */
  253. X            {
  254. X            int nb,f2,bz;
  255. X
  256. X            nb =          /* Figur neben Bauer    */
  257. X                (short)_npos(dat->lzug)
  258. X                - (short)posa==1 ||
  259. X                (short)_npos(dat->lzug)
  260. X                - (short)posa==-1
  261. X                ;
  262. X            f2 =          /* letzter Zug 2 Felder    */
  263. X                (short)_apos(dat->lzug)
  264. X                - (short)_npos(dat->lzug)==24 ||
  265. X                (short)_apos(dat->lzug)
  266. X                - (short)_npos(dat->lzug)==-24
  267. X                ;
  268. X            bz =         /* letzter zu Bauer    */
  269. X                _istbau(dat->brett[_npos(dat->lzug)])
  270. X                ;
  271. X            if(!(nb && f2 && bz))
  272. X            /* nicht e.p., also Abbruch        */
  273. X                continue;
  274. X            }
  275. X            }
  276. X            else        /* nicht schlagen    */
  277. X            if(!_istlee(dat->brett[posn]))
  278. X                break;
  279. X
  280. X            if(!(dat->farbe & _farbe(dat->brett[posn])))
  281. X                add(dat,nr,posa,posn);
  282. X                    /* Zug anhaengen    */
  283. X        }
  284. X        break;
  285. X    case 3:                /* X Koenig        */
  286. X        for(k=1;zug=zuege[_figur(fig)][k];k++)
  287. X                    /* alle Zuege durchg.    */
  288. X        {
  289. X            posn=(BYTE)((short)posa+zug);
  290. X
  291. X            if(k==1)    /* Rochade rechts    */
  292. X            {
  293. X                if(!_istlee(dat->brett[posa+1]))
  294. X                    continue;
  295. X                if(!_istxtur(dat->brett[posa+3]))
  296. X                    continue;
  297. X                if(bedrohung(dat,posa+1))
  298. X                    continue;
  299. X                if(bedrohung(dat,posa))
  300. X                    continue;
  301. X            }
  302. X
  303. X            if(k==2)    /* Rochade links    */
  304. X            {
  305. X                if(!_istlee(dat->brett[posa-1]))
  306. X                    continue;
  307. X                if(!_istlee(dat->brett[posa-3]))
  308. X                    continue;
  309. X                if(!_istxtur(dat->brett[posa-4]))
  310. X                    continue;
  311. X                if(bedrohung(dat,posa-1))
  312. X                    continue;
  313. X                if(bedrohung(dat,posa))
  314. X                    continue;
  315. X            }
  316. X
  317. X            if(!(dat->farbe & _farbe(dat->brett[posn])))
  318. X                add(dat,nr,posa,posn);
  319. X                    /* Zug anhaengen    */
  320. X        }
  321. X        break;
  322. X    }
  323. }
  324. X
  325. static     void    add(dat,nr,posa,posn)
  326. X
  327. SPDAT    *dat;                /* Spieldaten    */
  328. int    *nr;                /* Anzahl der eingetragen Zuege    */
  329. BYTE    posa,posn;            /* alte und neue Position    */
  330. {
  331. X    /* Bedrohung ueberpruefen bis minimale Rechentiefe        */
  332. X    if((mode&16) || /* Bedrohung immer ueberpruefen ?         */
  333. X    (spdat.maxstufe-dat->maxstufe < spdat.minstufe))
  334. X    /* ^ Falsche Berechnung beim Vorsortieren, daher dort mode|=16    */
  335. X    {
  336. X        BYTE figa,fign,pos;
  337. X        /* zieht Koenig selbst ? */
  338. X        if(posa==dat->wkpos || posa==dat->skpos)
  339. X            pos=posn;
  340. X        else if(dat->farbe==WEI)
  341. X            pos=dat->wkpos;
  342. X        else
  343. X            pos=dat->skpos;
  344. X
  345. X        figa=dat->brett[posa];        /* retten        */
  346. X        fign=dat->brett[posn];
  347. X
  348. X        dat->brett[posa]=LEE;        /* ziehen        */
  349. X        dat->brett[posn]=figa;
  350. X
  351. X        if(bedrohung(dat,pos))
  352. X        {
  353. X            dat->brett[posa]=figa;    /* zuruecknehmen    */
  354. X            dat->brett[posn]=fign;
  355. X            return;            /* Koenig bedroht    */
  356. X        }
  357. X
  358. X        dat->brett[posa]=figa;        /* zuruecknehmen    */
  359. X        dat->brett[posn]=fign;
  360. X    }
  361. X
  362. X    dat->zlist[(*nr)++]= posa+((WORD)posn<<8);    /* eintragen    */
  363. X    dat->zlist[*nr]= 0;                /* beenden    */
  364. }
  365. X
  366. /****************************************************************/
  367. /*    Zugliste sortieren                    */
  368. /****************************************************************/
  369. /*    Return:    Anzahl der Zuege                */
  370. /****************************************************************/
  371. X
  372. int    sortliste(dat,stufe)
  373. X
  374. SPDAT    *dat;                /* Spieldaten        */
  375. int    stufe;                /* Vorsortierstufe    */
  376. {
  377. X    int    anz;            /* Anzahl der Zuege    */
  378. X    int    minc,maxc;        /* Kopien der Stufen    */
  379. X    int    modec;            /* Kopie des Modus    */
  380. X    int    i,j;                /* Zaehler        */
  381. X    long    bew;                       /* Bewertung        */
  382. X    WORD    zug;            /* Zug            */
  383. X    WORD    bzug[MAXTIEFE];        /* beste Kombination    */
  384. X
  385. X    minc=dat->minstufe;        /* Stufen retten    */
  386. X    maxc=dat->maxstufe;
  387. X    modec=mode;
  388. X
  389. X    dat->minstufe=stufe;    /* Sortierstufen    */
  390. X    dat->maxstufe=stufe;
  391. X    mode |= 16;        /* Koenigsbedr. immer Ueberpruefen    */
  392. X
  393. X    comp_zug(dat,dat->farbe==WEI ? MATT:-MATT,bzug);
  394. X
  395. X    if(beende)            /* Beenden ?        */
  396. X        return(0);
  397. X
  398. X    dat->minstufe=minc;        /* wieder herstellen    */
  399. X    dat->maxstufe=maxc;
  400. X    mode=modec;
  401. X
  402. X    for(anz=0;dat->zlist[anz]!=(WORD)0;anz++)/* Anzahl bestimmen    */
  403. X        ;
  404. X
  405. X    for(i=0  ;i<anz-1;i++)            /* sortieren        */
  406. X    for(j=i+1;j<anz  ;j++)
  407. X        if(dat->farbe==WEI ?
  408. X        dat->blist[i]<dat->blist[j] : dat->blist[i]>dat->blist[j])
  409. X        {
  410. X            bew        =dat->blist[i];
  411. X            dat->blist[i]    =dat->blist[j];
  412. X            dat->blist[j]    =bew;
  413. X            zug        =dat->zlist[i];
  414. X            dat->zlist[i]    =dat->zlist[j];
  415. X            dat->zlist[j]    =zug;
  416. X        }
  417. X
  418. X    return(anz);
  419. }
  420. SHAR_EOF
  421. chmod 0644 ch/list.c ||
  422. echo 'restore of ch/list.c failed'
  423. Wc_c="`wc -c < 'ch/list.c'`"
  424. test 7783 -eq "$Wc_c" ||
  425.     echo 'ch/list.c: original size 7783, current size' "$Wc_c"
  426. rm -f _shar_wnt_.tmp
  427. fi
  428. # ============= ch/archiv.c ==============
  429. if test -f 'ch/archiv.c' -a X"$1" != X"-c"; then
  430.     echo 'x - skipping ch/archiv.c (File already exists)'
  431.     rm -f _shar_wnt_.tmp
  432. else
  433. > _shar_wnt_.tmp
  434. echo 'x - extracting ch/archiv.c (Text)'
  435. sed 's/^X//' << 'SHAR_EOF' > 'ch/archiv.c' &&
  436. /****************************************************************/
  437. /*                                */
  438. /*    XChess V2.7: Archiv                    */
  439. /*                                */
  440. /*    (c) 1991 by Marc Laukien                */
  441. /*                                */
  442. /****************************************************************/
  443. X
  444. #include <string.h>
  445. #include <stdio.h>
  446. #include <ctype.h>
  447. #include "ch.h"            /* Def. des Schachspiels */
  448. X
  449. extern    void    exit();
  450. extern    char    *malloc();
  451. extern    char    *memcpy();
  452. extern    void    free();
  453. X
  454. /****************************************************************/
  455. /*    Spiel speichern                        */
  456. /****************************************************************/
  457. /*    Return: 1-alles ok,     0-Fehler            */
  458. /****************************************************************/
  459. X
  460. int    save_game(name)
  461. X
  462. char    name[];                    /* Filename    */
  463. {
  464. X    FILE *fp;                /* Filepointer    */
  465. X    char na[STRLEN];            /* effektiver Name    */
  466. X    int  i;
  467. X
  468. X    while(*name==' ')            /* Spaces loeschen    */
  469. X        name++;
  470. X
  471. X    strcpy(na,name);            /* Name aufbereiten    */
  472. X    strcat(na,".ch");
  473. X
  474. X    if((fp=fopen(na,"w"))==(FILE *)0)    /* eroeffnen    */
  475. X        return(0);            /* Fehler    */
  476. X
  477. X    fwrite((char *)&spdat,sizeof(SPDAT),1,fp);    /* schreiben    */
  478. X    for(i=0;i<spdat.zuege+1;i++)
  479. X        fwrite((char *)archiv[i],sizeof(ARCHIV),1,fp);
  480. X    fwrite((char *)&mode,sizeof(mode),1,fp);
  481. X    fwrite((char *)&stufe,sizeof(stufe),1,fp);
  482. X    fwrite((char *)&varianten,sizeof(varianten),1,fp);
  483. X    fwrite((char *)&zeit,sizeof(zeit),1,fp);
  484. X    fwrite((char *)&varprosek,sizeof(varprosek),1,fp);
  485. X    fwrite((char *)&compzuege,sizeof(compzuege),1,fp);
  486. X
  487. X    fclose(fp);
  488. X
  489. X    return(1);
  490. }
  491. X
  492. /****************************************************************/
  493. /*    Spiel laden                        */
  494. /****************************************************************/
  495. /*    Return: 1-alles ok,     0-Fehler            */
  496. /****************************************************************/
  497. X
  498. int    load_game(name)
  499. X
  500. char    name[];                    /* Filename    */
  501. {
  502. X    FILE *fp;                /* Filepointer    */
  503. X    char na[STRLEN];            /* effektiver Name    */
  504. X    int  i;
  505. X
  506. X    while(*name==' ')            /* Spaces loeschen    */
  507. X        name++;
  508. X
  509. X    strcpy(na,name);            /* Name aufbereiten    */
  510. X    strcat(na,".ch");
  511. X
  512. X    if((fp=fopen(na,"r"))==(FILE *)0)    /* eroeffnen    */
  513. X        return(0);            /* Fehler    */
  514. X
  515. X    for(i=0;i<MAXSP;i++)            /* Speicher freigeben    */
  516. X        if(archiv[i]!=(ARCHIV *)0)
  517. X        {
  518. X            free(archiv[i]);
  519. X            archiv[i]=(ARCHIV *)0;
  520. X        }
  521. X
  522. X    fread((char *)&spdat,sizeof(SPDAT),1,fp);    /* lesen    */
  523. X    for(i=0;i<spdat.zuege+1;i++)
  524. X    {
  525. X        archiv[i]=(ARCHIV *)malloc((unsigned)sizeof(ARCHIV));
  526. X        if(archiv[i]==(ARCHIV *)0)    /* Fataler Fehler    */
  527. X            exit(1);
  528. X
  529. X        fread((char *)archiv[i],sizeof(ARCHIV),1,fp);
  530. X    }
  531. X    fread((char *)&mode,sizeof(mode),1,fp);
  532. X    fread((char *)&stufe,sizeof(stufe),1,fp);
  533. X    fread((char *)&varianten,sizeof(varianten),1,fp);
  534. X    fread((char *)&zeit,sizeof(zeit),1,fp);
  535. X    fread((char *)&varprosek,sizeof(varprosek),1,fp);
  536. X    fread((char *)&compzuege,sizeof(compzuege),1,fp);
  537. X
  538. X    fclose(fp);
  539. X
  540. X    return(1);
  541. }
  542. X
  543. /****************************************************************/
  544. /*    Spieldaten laden                    */
  545. /****************************************************************/
  546. /*    Return: 1-alles ok,     0-Fehler            */
  547. /****************************************************************/
  548. X
  549. int    load_spdat(name,dat)
  550. X
  551. char    name[];                    /* Filename        */
  552. SPDAT    *dat;                    /* Spieldaten        */
  553. {
  554. X    FILE *fp;                /* Filepointer        */
  555. X    char na[STRLEN];            /* effektiver Name    */
  556. X
  557. X    while(*name==' ')            /* Spaces loeschen    */
  558. X        name++;
  559. X
  560. X    strcpy(na,name);            /* Name aufbereiten    */
  561. X    strcat(na,".ch");
  562. X
  563. X    if((fp=fopen(na,"r"))==(FILE *)0)    /* eroeffnen    */
  564. X        return(0);            /* Fehler    */
  565. X
  566. X    fread((char *)dat,sizeof(SPDAT),1,fp);    /* lesen    */
  567. X
  568. X    fclose(fp);
  569. X
  570. X    return(1);
  571. }
  572. X
  573. /****************************************************************/
  574. /*    Spieldaten archivieren                    */
  575. /****************************************************************/
  576. X
  577. void    archiviere(dat)
  578. X
  579. SPDAT    *dat;                /* Spieldaten        */
  580. {
  581. X    int nr;                /* Zugnummer        */
  582. X    int i,j;
  583. X    BYTE fig1,fig2;
  584. X
  585. X    nr=dat->zuege;            /* Zugnummer bestimmen    */
  586. X
  587. X    if(nr>=MAXSP)            /* Speicher voll ?    */
  588. X        exit(1);        /* Fehler        */
  589. X
  590. X    if(archiv[nr]==(ARCHIV *)0)
  591. X    {
  592. X        archiv[nr]=(ARCHIV *)malloc((unsigned)sizeof(ARCHIV));
  593. X                        /* Speicher holen    */
  594. X        if(archiv[nr]==(ARCHIV *)0)    /* Fataler Fehler    */
  595. X            exit(1);
  596. X    }
  597. X
  598. X    memcpy((char *)archiv[nr]->brett,(char *)dat->brett,GROE);
  599. X                    /* Spielfeld kopieren        */
  600. X
  601. X    archiv[nr]->farbe=dat->farbe;    /* sonstige Daten kopieren    */
  602. X    archiv[nr]->wkpos=dat->wkpos;
  603. X    archiv[nr]->skpos=dat->skpos;
  604. X    archiv[nr]->lzug=dat->lzug;
  605. X
  606. X    archiv[nr]->wdh= -1;        /* Keine Wiederholung        */
  607. X    for(i=nr-1;i>=0;i--)        /* alle durchgehen        */
  608. X    {
  609. X        for(j=0;j<GROE;j++)
  610. X        {
  611. X            fig1=archiv[nr]->brett[j];
  612. X            if(_istxtur(fig1))
  613. X                fig1=TUR | _farbe(fig1);
  614. X            if(_istxkoe(fig1))
  615. X                fig1=KOE | _farbe(fig1);
  616. X
  617. X            fig2=archiv[i]->brett[j];
  618. X            if(_istxtur(fig2))
  619. X                fig2=TUR | _farbe(fig2);
  620. X            if(_istxkoe(fig2))
  621. X                fig2=KOE | _farbe(fig2);
  622. X
  623. X            if(fig1 != fig2)
  624. X                break;
  625. X        }
  626. X
  627. X        if(j==GROE)        /* Wiederholung gefunden     */
  628. X        {
  629. X            archiv[nr]->wdh=i;
  630. X            break;
  631. X        }
  632. X    }
  633. }
  634. X
  635. /****************************************************************/
  636. /*    Spieldaten zurueckholen                    */
  637. /****************************************************************/
  638. /*    0: Fehler    1: ok                    */
  639. /****************************************************************/
  640. X
  641. int    hole_zurueck(dat,nr)
  642. X
  643. SPDAT    *dat;                /* Spieldaten        */
  644. int     nr;                /* Zugnummer        */
  645. {
  646. X    if(nr>=MAXSP || nr<0)
  647. X        return(0);        /* Fehler        */
  648. X
  649. X    if(archiv[nr]==(ARCHIV *)0)    /* nicht belegt ?    */
  650. X        return(0);        /* Fehler        */
  651. X
  652. X    dat->zuege=nr;            /* Zugnummer bestimmen    */
  653. X
  654. X    memcpy((char *)dat->brett,(char *)archiv[nr]->brett,GROE);
  655. X                    /* Spielfeld kopieren    */
  656. X
  657. X    dat->farbe=archiv[nr]->farbe;    /* sonstige Daten kop.    */
  658. X    dat->wkpos=archiv[nr]->wkpos;
  659. X    dat->skpos=archiv[nr]->skpos;
  660. X    dat->lzug =archiv[nr]->lzug;
  661. X
  662. X    return(1);
  663. }
  664. SHAR_EOF
  665. chmod 0644 ch/archiv.c ||
  666. echo 'restore of ch/archiv.c failed'
  667. Wc_c="`wc -c < 'ch/archiv.c'`"
  668. test 5629 -eq "$Wc_c" ||
  669.     echo 'ch/archiv.c: original size 5629, current size' "$Wc_c"
  670. rm -f _shar_wnt_.tmp
  671. fi
  672. # ============= ch/open.c ==============
  673. if test -f 'ch/open.c' -a X"$1" != X"-c"; then
  674.     echo 'x - skipping ch/open.c (File already exists)'
  675.     rm -f _shar_wnt_.tmp
  676. else
  677. > _shar_wnt_.tmp
  678. echo 'x - extracting ch/open.c (Text)'
  679. sed 's/^X//' << 'SHAR_EOF' > 'ch/open.c' &&
  680. /****************************************************************/
  681. /*                                */
  682. /*    XChess V2.7: Eroeffnung und Spielphase            */
  683. /*                                */
  684. /*    (c) 1991 by Marc Laukien                */
  685. /*                                */
  686. /****************************************************************/
  687. X
  688. #include <math.h>
  689. #include <stdio.h>
  690. #include "ch.h"            /* Def. des Schachspiels     */
  691. #include "ph.h"            /* Def. der Spielphasen        */
  692. X
  693. static    WORD    op_zug();
  694. X
  695. /****************************************************************/
  696. /*    effektive Stufe einstellen und Spielphase erkennen    */
  697. /****************************************************************/
  698. X
  699. void    eff_stufe(dat)
  700. X
  701. SPDAT     *dat;                /* Spieldaten            */
  702. {
  703. X    double    wanz,sanz;        /* Anzahl der Figurenbew.    */
  704. X    int    w_b,w_sl,w_td;        /* Anzahl der weissen Figuren    */
  705. X    int    s_b,s_sl,s_td;        /* Anzahl der schwarzen Figuren    */
  706. X    WORD    pos;
  707. X    static    double bew[]=        /* Bewgungsfreiheit        */
  708. X                    /* unter opt. Bedingungen    */
  709. X    {BWLEE,BWBAU,BWXBAU,BWSPR,BWLAE,BWTUR,BWXTUR,BWDAM,BWKOE,BWXKOE};
  710. X    static    double maxanz=        /* Bewegunsfreiheit am Anfang    */
  711. X    2* (8*BWXBAU + 2*BWSPR + 2*BWLAE + 2*BWXTUR + BWDAM + BWXKOE);
  712. X
  713. X    wanz=0.; sanz=0.;        /* loeschen    */
  714. X    w_b=0; w_sl=0; w_td=0;
  715. X    s_b=0; s_sl=0; s_td=0;
  716. X
  717. X    for(pos=RAND*ZLEN,wanz=0.,sanz=0.;pos<GROE-RAND*ZLEN;pos++)
  718. X        if(_istwei(dat->brett[pos]))
  719. X        {
  720. X            wanz+=bew[_figur(dat->brett[pos])];
  721. X            switch(_figur(dat->brett[pos]))
  722. X            {
  723. X            case BAU:        /* Anzahl der Figuren    */
  724. X            case XBAU:        /* bestimmen        */
  725. X                w_b++;
  726. X                break;
  727. X            case SPR:
  728. X            case LAE:
  729. X                w_sl++;
  730. X                break;
  731. X            case TUR:
  732. X            case XTUR:
  733. X            case DAM:
  734. X                w_td++;
  735. X                break;
  736. X            }
  737. X        }
  738. X        else if(_istsch(dat->brett[pos]))
  739. X        {
  740. X            sanz+=bew[_figur(dat->brett[pos])];
  741. X            switch(_figur(dat->brett[pos]))
  742. X            {
  743. X            case BAU:        /* Anzahl der Figuren    */
  744. X            case XBAU:        /* bestimmen        */
  745. X                s_b++;
  746. X                break;
  747. X            case SPR:
  748. X            case LAE:
  749. X                s_sl++;
  750. X                break;
  751. X            case TUR:
  752. X            case XTUR:
  753. X            case DAM:
  754. X                s_td++;
  755. X                break;
  756. X            }
  757. X        }
  758. X
  759. X    /*** Phasenerkennung ********************************************/
  760. X
  761. X    /* Bei Spielbeginn gibt es 16 Bauern und 14 Offiziere        */
  762. X
  763. X    if(s_b+s_sl+s_td+w_b+w_sl+w_td == 0)    /* Remis ?        */
  764. X        phase=REMIS;
  765. X    else if(!w_sl && !w_td)    /* Weisser Koenig ohne Offiziere ?    */
  766. X        phase=WKOEOO;
  767. X    else if(!s_sl && !s_td)    /* Schwarzer Koenig ohne Offiziere ?    */
  768. X        phase=SKOEOO;
  769. X    else if(w_b+s_b<=8 || w_sl+w_td+s_sl+s_td<=7)
  770. X        phase=ENDSPI;        /* Endspiel            */
  771. X    else if(w_b+s_b<=12 || w_sl+w_td+s_sl+s_td<=12)
  772. X        phase=MITTEL;        /* Mittelspiel            */
  773. X    else
  774. X        phase=EROEFF;        /* Eroeffnung            */
  775. X
  776. X    /*** Ende Phasenerkennung ***************************************/
  777. X
  778. X    if(mode&8 && wanz != 0 && sanz != 0)    /* Stufenanpassung ?    */
  779. X    {
  780. X        dat->minstufe=        /* Rechentiefen        */
  781. X        (int) ((double)mintiefe[stufe]*log(maxanz)/log(wanz+sanz)+.5);
  782. X        dat->maxstufe=
  783. X        (int) ((double)maxtiefe[stufe]*log(maxanz)/log(wanz+sanz)+.5);
  784. X        if(dat->maxstufe%2 != 0)
  785. X            dat->maxstufe--;
  786. X
  787. X        /* Maximal doppelt    */
  788. X
  789. X        if(dat->minstufe>mintiefe[stufe]*2)
  790. X            dat->minstufe=mintiefe[stufe]*2;
  791. X
  792. X        if(dat->maxstufe>maxtiefe[stufe]*2)
  793. X            dat->maxstufe=maxtiefe[stufe]*2;
  794. X    }
  795. X    else
  796. X    {
  797. X        dat->minstufe=mintiefe[stufe];
  798. X        dat->maxstufe=maxtiefe[stufe];
  799. X    }
  800. }
  801. X
  802. /****************************************************************/
  803. /*    Zug aus Bibliothek suchen                */
  804. /****************************************************************/
  805. /*    Return:    Zug oder 0 falls keiner gefunden        */
  806. /****************************************************************/
  807. X
  808. WORD bib_zug()
  809. X
  810. {
  811. X    int     j,i,anz=0;
  812. X    int    mgl[MAXOP];        /* Liste mit mgl. Eroeffnungen    */
  813. X    WORD    ko[MAXSP];        /* Kombination        */
  814. X
  815. X    if(!(mode&32) || noop<=0)     /* Bibliothek aus ?     */
  816. X        return((WORD)0);
  817. X
  818. X    noop--;                /* Bibl.zaehler erniedrigen    */
  819. X
  820. X    if(mode&64)        /* bestimmte Eroeffnung nehmen    */
  821. X    {
  822. X        i=testopnr;
  823. X
  824. X        for(j=0;j<spdat.zuege && op[i][j]!=(WORD)0;j++)
  825. X            if(archiv[j+1]->lzug!=op[i][j])
  826. X                break;    /* passt nicht        */
  827. X
  828. X        if(j==spdat.zuege && op[i][j]!=(WORD)0)
  829. X        {            /* passt        */
  830. X            mgl[anz++]=i;
  831. X            noop=OPTRYS;    /* Bibl. wieder oeffnen    */
  832. X        }
  833. X    }
  834. X    else
  835. X        for(i=0;i<opnr;i++)        /* Eroeffnungen testen    */
  836. X        {
  837. X            for(j=0;j<spdat.zuege;j++) /* Komb. erstellen    */
  838. X                ko[j]=archiv[j+1]->lzug;
  839. X
  840. X            ko[j]=(WORD)0;        /* beenden    */
  841. X
  842. X
  843. X            if(op_zug(ko,&op[i][0]) != (WORD)0)
  844. X            {            /* Zug gefunden        */
  845. X                if(op_fa[i] & spdat.farbe)
  846. X                    mgl[anz++]=i;
  847. X                /* Eroeffnung fuer die richtige Farbe    */
  848. X                
  849. X                noop=OPTRYS;    /* Bibl. wieder oeffnen    */
  850. X                /* ^ Wichtig ! Die Bib. muss auch er-    */
  851. X                /* oeffnet werden, wenn die Farbe nicht    */
  852. X                /* stimmt, da sonst beim naechsten Zug    */
  853. X                /* fuer die andere Farbe nicht mehr     */
  854. X                /* nachgesehen wird.            */
  855. X            }
  856. X        }
  857. X
  858. X    if(anz == 0)
  859. X        return((WORD)0);    /* nix gefunden        */
  860. X
  861. X    i=rand();                  /* zufaellig beginnen    */
  862. X    while(i>=anz)
  863. X        i -= anz;
  864. X
  865. #ifdef    ANALYSE        /* einfache Analyse ein ?    */
  866. X    if(mode & 128)
  867. X    {
  868. X        WORD komb[2];                /* Kombination    */
  869. X        char str[STRLEN];
  870. X
  871. X        komb[0]=op[mgl[i]][spdat.zuege];    /* eintragen    */
  872. X        komb[1]=(WORD)0;            /* beenden    */
  873. X
  874. X        strcpy(str,kombination(&spdat,komb));
  875. X        strcat(str," (Library)");
  876. X        ANALYSE(str);
  877. X    }
  878. #endif
  879. X
  880. X    return(op[mgl[i]][spdat.zuege]);    /* gefunden    */
  881. }
  882. X
  883. static    WORD    op_zug(ko,er)
  884. X
  885. WORD    *ko,*er;    /* Kombination, Eroeffnung    */
  886. {
  887. X    int    len,i,j;
  888. X    WORD    ek[MAXSP];    /* Kopie der Eroeffnung    */
  889. X
  890. X    len=spdat.zuege;    /* Laenge der Kombination feststellen */
  891. X
  892. X    for(i=0;i<len+1;i++)    /* er in ek kopieren    */
  893. X    {
  894. X        if(er[i]==(WORD)0)     /* Kombination laenger als     */
  895. X            return((WORD)0); /* Eroeffnung            */
  896. X
  897. X        ek[i]=er[i];
  898. X    }
  899. X
  900. X    ek[len]=(WORD)0;    /* beenden    */
  901. X
  902. X    for(i=0;i<len;i += 2)    /* Weisse Zuege durchsuchen    */
  903. X    {
  904. X        for(j=0;j<len;j += 2)
  905. X            if(ek[j]==ko[i])    /* Zug gefunden    */
  906. X            {
  907. X                ek[j]=(WORD)0;    /* streichen    */
  908. X                break;
  909. X            }
  910. X
  911. X        if(j>=len)    /* Zug nicht gefunden    */
  912. X            return((WORD)0);
  913. X    }
  914. X
  915. X    for(i=1;i<len;i += 2)    /* Schwarze Zuege durchsuchen    */
  916. X    {
  917. X        for(j=1;j<len;j += 2)
  918. X            if(ek[j]==ko[i])    /* Zug gefunden    */
  919. X            {
  920. X                ek[j]=(WORD)0;    /* streichen    */
  921. X                break;
  922. X            }
  923. X
  924. X        if(j>=len)    /* Zug nicht gefunden    */
  925. X            return((WORD)0);
  926. X    }
  927. X
  928. X    return(er[len]);    /* Zug als Ergebnis    */
  929. }
  930. X
  931. /****************************************************************/
  932. /*    Eroeffungen aus Bibliothek testen            */
  933. /****************************************************************/
  934. /*    Return:    1: alles ok    0: Fehler            */
  935. /****************************************************************/
  936. X
  937. int     bib_test()
  938. X
  939. {
  940. X    FILE    *fp2,*fp=(FILE *)0;    /* Filepointer        */
  941. X    int    zug;            /* Zugnummer        */
  942. X    int    mode2;
  943. X    char    str[200*5];
  944. X    int    i;
  945. X
  946. X    mode2 = mode;            /* retten        */
  947. X
  948. X    mode &= !(1+128);        /* Analyse aus        */
  949. X    mode |=    32+64;            /* Eroeffnungstest ein    */
  950. X
  951. X    init(&spdat,1);            /* Initialisierungen    */
  952. X
  953. X    testopnr=0;            /* Eroeffungsnummer    */
  954. X
  955. X    if((fp2=fopen("chess.op","r"))==(FILE *)0)    /* oeffnen    */
  956. X        exit(1);                                /* Fehler     */
  957. X
  958. X    while(testopnr<opnr)
  959. X    {
  960. X        while(!feof(fp2))    /* Eroeffnung suchen    */
  961. X               {
  962. X            fgets(str,999,fp2);      /* einlesen     */
  963. X
  964. X                    i=0;
  965. X            while(str[i]!='#' && str[i]!='\n' && str[i]!=0)
  966. X                i++;
  967. X
  968. X            str[i]=0;               /* beenden     */
  969. X
  970. X            if(strlen(str))    /* Keine Leerzeile  ?    */
  971. X                break;
  972. X        }
  973. X
  974. X        zug=0;            /* erster Zug        */
  975. X
  976. fprintf(stderr,"%d/%d\n",testopnr+1,opnr);
  977. X
  978. X        while((spdat.bzug=bib_zug())!=(WORD)0)    /* Zug in Bib. ?*/
  979. X        {
  980. X            if(zug_test(&spdat,spdat.bzug))    /* Testen    */
  981. X            {
  982. X                ziehe(&spdat,spdat.bzug);/* ziehen    */
  983. X                archiviere(&spdat);    /* speichern    */
  984. X                zug++;
  985. X            }
  986. X            else                /* Fehler !    */
  987. X            {
  988. X                /* Fehlerfile oeffnen    */
  989. X                if(fp==(FILE *)0)
  990. X                    fp=fopen("error.op","w");
  991. X
  992. X                fprintf(fp,"%d%c%d/%d:\n%s\n",
  993. X                testopnr+1,TAB,zug/2+1,zug%2+1,str);
  994. X                break;
  995. X            }
  996. X        }
  997. X    
  998. X        testopnr++;        /* naechste Eroeffung    */
  999. X
  1000. X        init(&spdat,1);        /* Initialisierungen    */
  1001. X    }
  1002. X
  1003. X    mode=mode2;        /* wieder herstellen    */
  1004. X    
  1005. X    fclose(fp2);
  1006. X
  1007. X    if(fp!=(FILE *)0)    /* Fehler gefunden ?    */
  1008. X    {
  1009. X        fclose(fp);    /* schliessen     */
  1010. X        return(0);    /* Fehler !    */
  1011. X    }
  1012. X    else
  1013. X        return(1);    /* alles ok    */
  1014. }
  1015. SHAR_EOF
  1016. chmod 0644 ch/open.c ||
  1017. echo 'restore of ch/open.c failed'
  1018. Wc_c="`wc -c < 'ch/open.c'`"
  1019. test 7762 -eq "$Wc_c" ||
  1020.     echo 'ch/open.c: original size 7762, current size' "$Wc_c"
  1021. rm -f _shar_wnt_.tmp
  1022. fi
  1023. # ============= ch/stat.c ==============
  1024. if test -f 'ch/stat.c' -a X"$1" != X"-c"; then
  1025.     echo 'x - skipping ch/stat.c (File already exists)'
  1026.     rm -f _shar_wnt_.tmp
  1027. else
  1028. > _shar_wnt_.tmp
  1029. echo 'x - extracting ch/stat.c (Text)'
  1030. sed 's/^X//' << 'SHAR_EOF' > 'ch/stat.c' &&
  1031. /****************************************************************/
  1032. /*                                */
  1033. /*    XChess V2.7: Status                    */
  1034. /*                                */
  1035. /*    (c) 1991 by Marc Laukien                */
  1036. /*                                */
  1037. /****************************************************************/
  1038. X
  1039. #include <string.h>
  1040. #include <stdio.h>
  1041. #include <ctype.h>
  1042. #include "ch.h"            /* Def. des Schachspiels */
  1043. #include "ph.h"            /* Spielphase         */
  1044. X
  1045. /****************************************************************/
  1046. /*    Status bestimmen                    */
  1047. /****************************************************************/
  1048. X
  1049. void    status_aus(dat,ret)
  1050. X
  1051. SPDAT     *dat;                /* Spieldaten        */
  1052. char    *ret[];                /* Antworten        */
  1053. {
  1054. X    int    anz;            /* Zaehler        */
  1055. X    char    bed;            /* Bedrohung        */
  1056. X    int     i;
  1057. X
  1058. X    eff_stufe(dat);            /* Phasenerkennung    */
  1059. X
  1060. X    /*--- Test auf 3-fache Wiederholung --------------------*/
  1061. X
  1062. X    for(i=dat->zuege;i>=0;i--)    /* Wdh. finden        */
  1063. X        if(archiv[i]->wdh != -1)
  1064. X        if(archiv[archiv[i]->wdh]->wdh!= -1)
  1065. X            break;        /* gefunden        */
  1066. X
  1067. X    if(i > -1)            /* 3-fache Wiederholung    */
  1068. X    {
  1069. X        sprintf(ret[zaehler++],"3");
  1070. X        return;
  1071. X    }
  1072. X
  1073. X    /*--- Test, ob Koenige fehlen ---------------------------*/
  1074. X
  1075. X    if(dat->wkpos==(BYTE)0 && dat->skpos==(BYTE)0)
  1076. X    {
  1077. X        strcpy(ret[zaehler++],"r");    /* Remis         */
  1078. X        return;
  1079. X    }
  1080. X    else if(dat->wkpos==(BYTE)0)
  1081. X    {
  1082. X        strcpy(ret[zaehler++],"mw");    /* Weiss ist matt    */
  1083. X        return;
  1084. X    }
  1085. X    else if(dat->skpos==(BYTE)0)
  1086. X    {
  1087. X        strcpy(ret[zaehler++],"ms");    /* Schwarz ist matt    */
  1088. X        return;
  1089. X    }
  1090. X
  1091. X    /*--- Spielphase auf Remis untersuchen -----------------*/
  1092. X
  1093. X    if(phase==REMIS)
  1094. X    {
  1095. X        strcpy(ret[zaehler++],"r");
  1096. X        return;
  1097. X    }
  1098. X
  1099. X    /*--- Test auf Matt und Patt und Schach ----------------*/
  1100. X
  1101. X    anz=zugliste(dat,(BYTE)0);    /* Zuege bestimmen    */
  1102. X
  1103. X    if(dat->farbe==WEI && bedrohung(dat,dat->wkpos))
  1104. X        bed='w';
  1105. X    else if(dat->farbe==SCH && bedrohung(dat,dat->skpos))
  1106. X        bed='s';
  1107. X    else
  1108. X        bed='\0';
  1109. X
  1110. X    if(!anz)            /* Matt oder Patt ?    */
  1111. X    {
  1112. X        if(bed=='\0')        /* Patt ?        */
  1113. X            strcpy(ret[zaehler++],"p");
  1114. X
  1115. X        else            /* Matt         */
  1116. X            sprintf(ret[zaehler++],"m%c",bed);
  1117. X    }
  1118. X    else                /* nur Schach oder nix    */
  1119. X        sprintf(ret[zaehler++],"%c",bed);
  1120. }
  1121. SHAR_EOF
  1122. chmod 0644 ch/stat.c ||
  1123. echo 'restore of ch/stat.c failed'
  1124. Wc_c="`wc -c < 'ch/stat.c'`"
  1125. test 2027 -eq "$Wc_c" ||
  1126.     echo 'ch/stat.c: original size 2027, current size' "$Wc_c"
  1127. rm -f _shar_wnt_.tmp
  1128. fi
  1129. # ============= ad/main.c ==============
  1130. if test ! -d 'ad'; then
  1131.     echo 'x - creating directory ad'
  1132.     mkdir 'ad'
  1133. fi
  1134. if test -f 'ad/main.c' -a X"$1" != X"-c"; then
  1135.     echo 'x - skipping ad/main.c (File already exists)'
  1136.     rm -f _shar_wnt_.tmp
  1137. else
  1138. > _shar_wnt_.tmp
  1139. echo 'x - extracting ad/main.c (Text)'
  1140. sed 's/^X//' << 'SHAR_EOF' > 'ad/main.c' &&
  1141. /****************************************************************/
  1142. /*                                */
  1143. /*    XChess V2.7 Adapter: Curses                */
  1144. /*                                */
  1145. /*    (c) 1991 by Marc Laukien                */
  1146. /*                                */
  1147. /*    Programmteil:    Hauptprogramm                */
  1148. /*                                */
  1149. /****************************************************************/
  1150. X
  1151. #include <curses.h>
  1152. #include <stdio.h>
  1153. #include <string.h>
  1154. #include <fcntl.h>
  1155. #include "ad.h"
  1156. X
  1157. char    *pname;            /* Prgname: argv[0]         */
  1158. char    *cwd;            /* Working Directory         */
  1159. char    stdname[STRLEN]="";    /* Standardname fuers Speichern    */
  1160. char    def[STRLEN]=LANG;    /* Definitionen            */
  1161. int    lock=0;            /* Falls 1: Lock erworben    */
  1162. int    curses=0;        /* Falls 1: Curses an        */
  1163. int    inter;            /* Falls 1: Es war ein Interrupt*/
  1164. int    break_pid= -1;        /* Prozessid des Unterbrechers    */
  1165. WINDOW    *win=(WINDOW *)0;    /* Subwindow            */
  1166. WINDOW    *setupwin=(WINDOW *)0;    /* Setup-Subwindow        */
  1167. X
  1168. char    farbe;            /* w=weiss,s=schwarz        */
  1169. int    wei;            /* 0=Spieler            */
  1170. int    sch;            /* 1=Computer oder Gegener    */
  1171. char    gegner[STRLEN];        /* Spielgegner (leer:Computer)    */
  1172. int    level;            /* Spielstufe            */
  1173. int    ende;            /* 1:Matt oder Patt        */
  1174. int    modus;            /* eingestellter Modus        */
  1175. char    ant[PTR][81];        /* Antworten            */
  1176. char    *ptr[PTR];        /* Pointer auf Antw.        */
  1177. X
  1178. int    old_moves;    /* Anzahl der Zuege bei Spielbeginn    */
  1179. /* ^ Wird benoetigt, um festzustellen, ob beim Verlassen    */
  1180. /* eines Turnierspieles gegen den Computer (regulaer oder    */
  1181. /* durch Interrupt) Speichern noetig ist            */
  1182. X
  1183. extern    void    exit();
  1184. extern    int    umask();
  1185. X
  1186. /****************************************************************/
  1187. /*    Hauptprogramm                        */
  1188. /****************************************************************/
  1189. X
  1190. int    main(argc,argv,envp)
  1191. X
  1192. int     argc;
  1193. char     *argv[];
  1194. char     *envp[];
  1195. {
  1196. X    extern     char     *optarg;
  1197. X    extern     int      optind,opterr;
  1198. X    char        c;
  1199. X    char        str[STRLEN];
  1200. X    int        testop=0;    /* Falls 1: Eroeffungen testen    */
  1201. X    int        expire=0;    /* Falls 1: Expire        */
  1202. X    int        i;
  1203. X
  1204. X    umask(077);            /* Filecreationmask    */
  1205. X
  1206. X    pname=argv[0];            /* Programmname     */
  1207. X
  1208. X    for(i=0;i<PTR;i++)        /* Pointer setzen     */
  1209. X        ptr[i]= &ant[i][0];
  1210. X
  1211. X    cwd=getcwd((char *)0,STRLEN);    /* Directory retten     */
  1212. X
  1213. X    if(chdir(WORKDIR)== -1)        /* Directory aendern    */
  1214. X    {
  1215. X        fprintf(stderr,
  1216. X        "%s: unknown path %s\n",pname,WORKDIR);
  1217. X        exit(1);
  1218. X    }
  1219. X
  1220. X    /* Optionen einlesen *******************************************/
  1221. X
  1222. X    opterr=1;
  1223. X    while((c=(char)getopt(argc,argv,"etd:"))!=EOF)
  1224. X        switch(c)
  1225. X        {
  1226. X        case 'd':        /* andere Sprache         */
  1227. X            strcpy(def,optarg);
  1228. X            break;
  1229. X
  1230. X        case 't':        /* Eroeffungsbibliothek testen    */
  1231. X            testop=1;
  1232. X            break;
  1233. X
  1234. X        case 'e':        /* Expire    */
  1235. X            expire=1;
  1236. X            break;
  1237. X
  1238. X        default:
  1239. X        case '?':        /* Fehler     */
  1240. X            opterr++;
  1241. X            break;
  1242. X        }
  1243. X
  1244. X    if(opterr>1)            /* falsche Optionen */
  1245. X    {
  1246. X        fprintf(stderr,
  1247. X        "usage: %s [-t] [-e] [-d file]\n",pname);
  1248. X        ad_deinit();
  1249. X        exit(1);
  1250. X    }
  1251. X    
  1252. X    /* Ende Optionen einlesen **************************************/
  1253. X
  1254. X    if(testop)            /* Eroeffungen testen    */
  1255. X    {
  1256. X        schach("testbib",ptr);
  1257. X
  1258. X        if(ptr[0][0]=='?')        /* Fehler ?        */
  1259. X        {
  1260. X            fprintf(stderr,
  1261. X    "%s: error in chess.op (see error.op for more information)\n",pname);
  1262. X            ad_deinit();
  1263. X            exit(1);
  1264. X        }
  1265. X        else
  1266. X            fprintf(stderr,"%s: no errors in chess.op\n",pname);
  1267. X
  1268. X    }
  1269. X    else if(expire)            /* Expire ?    */
  1270. X    {
  1271. X        ad_expire();
  1272. X    }
  1273. X    else    /* Normales Spiel    */
  1274. X    {
  1275. X        ad_init();            /* initialsieren    */
  1276. X
  1277. X        ad_admin();            /* Administrationsmenue    */
  1278. X
  1279. X        ad_deinit();            /* deinitialsieren    */
  1280. X    }
  1281. X
  1282. X    return(0);            /* alles ok        */
  1283. }
  1284. SHAR_EOF
  1285. chmod 0644 ad/main.c ||
  1286. echo 'restore of ad/main.c failed'
  1287. Wc_c="`wc -c < 'ad/main.c'`"
  1288. test 3355 -eq "$Wc_c" ||
  1289.     echo 'ad/main.c: original size 3355, current size' "$Wc_c"
  1290. rm -f _shar_wnt_.tmp
  1291. fi
  1292. # ============= ad/init.c ==============
  1293. if test -f 'ad/init.c' -a X"$1" != X"-c"; then
  1294.     echo 'x - skipping ad/init.c (File already exists)'
  1295.     rm -f _shar_wnt_.tmp
  1296. else
  1297. > _shar_wnt_.tmp
  1298. echo 'x - extracting ad/init.c (Text)'
  1299. sed 's/^X//' << 'SHAR_EOF' > 'ad/init.c' &&
  1300. /****************************************************************/
  1301. /*                                */
  1302. /*    XChess V2.7 Adapter: Curses                */
  1303. /*                                */
  1304. /*    (c) 1991 by Marc Laukien                */
  1305. /*                                */
  1306. /*    Programmteil:    Initialisierungen            */
  1307. /*                                */
  1308. /****************************************************************/
  1309. X
  1310. #include <curses.h>
  1311. #include <stdio.h>
  1312. #include <signal.h>
  1313. #include <string.h>
  1314. #include "ad.h"
  1315. X
  1316. extern    void    exit();
  1317. X
  1318. static    struct    termio    term,oterm;    /* Terminaldaten */
  1319. X
  1320. /****************************************************************/
  1321. /*    Initialisierungen                    */
  1322. /****************************************************************/
  1323. X
  1324. void    ad_init()
  1325. {
  1326. X    int     i,ch;
  1327. X    int     pfd[2];
  1328. X
  1329. X    lex();                /* Strings einlesen     */
  1330. X
  1331. X    if(startcmd[0]!=(char)0)
  1332. X        system(startcmd);    /* Startkommando ausf.    */
  1333. X
  1334. X    /**** Unterbrecher starten            ****/
  1335. X
  1336. X    if(pipe(pfd)== -1)    /* Pipe erzeugen    */
  1337. X    {            /* Fehler ?    */
  1338. X        ad_error("");
  1339. X        ad_deinit();
  1340. X        exit(1);
  1341. X    }
  1342. X
  1343. X    if((break_pid=fork())== -1)    /* Fehler ?    */
  1344. X    {
  1345. X        ad_error("");
  1346. X        ad_deinit();
  1347. X        exit(1);
  1348. X    }
  1349. X
  1350. X    if(break_pid==0)    /* Sohn ?    */
  1351. X    {
  1352. X        close(1);    /* Standardausgabe schliessen    */
  1353. X        dup(pfd[1]);    /* neue Standardausgabe        */
  1354. X        close(pfd[0]);    /* Pipes schliessen        */
  1355. X        close(pfd[1]);
  1356. X        execlp("./chbrk","./chbrk",(char *)0);    /* starten    */
  1357. X        ad_error("");
  1358. X        ad_deinit();
  1359. X        exit(1);
  1360. X    }
  1361. X    else            /* Vater ?    */
  1362. X    {
  1363. X        close(0);    /* Standardeingabe schliessen    */
  1364. X        dup(pfd[0]);    /* neue Standardeingabe        */
  1365. X        close(pfd[0]);    /* Pipes schliessen        */
  1366. X        close(pfd[1]);
  1367. X    }
  1368. X
  1369. X    /**** Ende Unterbrecher starten            ****/
  1370. X
  1371. X    initscr();            /* Curses ein        */
  1372. X    curses=1;
  1373. X
  1374. X    if(ioctl(1,TCGETA,&oterm)== -1)    /* termio retten */
  1375. X    {
  1376. X        ad_error("");
  1377. X        ad_deinit();
  1378. X        exit(1);
  1379. X    }
  1380. X
  1381. X    if(ioctl(1,TCGETA,&term)== -1)    /* termio holen */
  1382. X    {
  1383. X        ad_error("");
  1384. X        ad_deinit();
  1385. X        exit(1);
  1386. X    }
  1387. X
  1388. X    term.c_cc[VEOF]=1;        /* veraendern */
  1389. X    term.c_cc[VEOL]=1;
  1390. X    term.c_lflag &= ~(ICANON | ECHO);
  1391. X
  1392. X    if(ioctl(1,TCSETA,&term))
  1393. X    {
  1394. X        ad_error("");
  1395. X        ad_deinit();
  1396. X        exit(1);
  1397. X    }
  1398. X
  1399. X    ad_startint();        /* Interrupt starten    */
  1400. }
  1401. X
  1402. /****************************************************************/
  1403. /*    Deinitialisierungen                    */
  1404. /****************************************************************/
  1405. X
  1406. void    ad_deinit()
  1407. {
  1408. X    if(break_pid!= -1)        /* Unterbrecher laeuft ?*/
  1409. X        kill(break_pid,SIGTERM);/* beenden        */
  1410. X
  1411. X    if(lock==1)            /* Lock erworben ?    */
  1412. X        ad_unlock();        /* freigeben        */
  1413. X
  1414. X    if(curses==1)            /* Curses an ?        */
  1415. X    {
  1416. X        char    s[STRLEN];
  1417. X
  1418. X        ioctl(1,TCSETA,&oterm);    /* termio herstellen     */
  1419. X        endwin();        /* Curses aus        */
  1420. X
  1421. X        if(stdname[0]!='\0' && !ende && UEBUNG())
  1422. X        {
  1423. X            ad_lock();
  1424. X            sprintf(s,"save %s",stdname);
  1425. X            schach(s,ptr);        /* Speichern        */
  1426. X            ad_unlock();
  1427. X        }
  1428. X
  1429. X        if(stdname[0]!='\0' && !ende && TURNCOM())
  1430. X        {
  1431. X            schach("info",ptr);    /* Info holen    */
  1432. X
  1433. X            if(atoi(ptr[1]) != old_moves)
  1434. X            {        /* veraendert ?        */
  1435. X                ad_lock();
  1436. X                sprintf(s,"save %s",stdname);
  1437. X                schach(s,ptr);    /* Speichern    */
  1438. X                ad_unlock();
  1439. X            }
  1440. X        }
  1441. X    }
  1442. X
  1443. X    fflush(stdout);            /* Buffer leeren    */
  1444. X    fflush(stdin);
  1445. X
  1446. X    chdir(cwd);            /* Directory herstellen    */
  1447. }
  1448. X
  1449. /****************************************************************/
  1450. /*    Neustart                        */
  1451. /****************************************************************/
  1452. X
  1453. void    ad_new()
  1454. {
  1455. X    static    int    first=1;
  1456. X
  1457. X    if(first)    /* Laden der Bib. einmal anzeigen    */
  1458. X    {
  1459. X        ad_msg(load_lib);
  1460. X        first=0;
  1461. X    }
  1462. X
  1463. X    schach("init",ptr);        /* Initialsieren     */
  1464. X    if(ptr[0][0]=='?')        /* Fehler ?        */
  1465. X    {
  1466. X        ad_error("");
  1467. X        ad_deinit();
  1468. X        exit(1);
  1469. X    }
  1470. X    schach("stufe 2",ptr);        /* Stufe einstellen    */
  1471. X
  1472. X    if(UEBUNG())            /* Uebungsspiel ?    */
  1473. X    {
  1474. X        char    str[STRLEN];
  1475. X
  1476. X        sprintf(str,"stufe %d",atoi(tr_lv)-1);
  1477. X        schach(str,ptr);    /* Level einstellen    */
  1478. X
  1479. X        wei=0;            /* 0=Spieler        */
  1480. X        sch=1;            /* 1=Computer        */
  1481. X    }
  1482. X
  1483. X    if(TURNIER())            /* Turnierspiel        */
  1484. X    {
  1485. X        char    str[STRLEN];
  1486. X
  1487. X        sprintf(str,"stufe %d",atoi(to_lv)-1);
  1488. X        schach(str,ptr);    /* Level einstellen    */
  1489. X    }
  1490. X
  1491. X    ende=0;                /* 1:Matt oder Patt    */
  1492. X
  1493. X    ad_brett();        /* Brett aufbauen    */
  1494. X
  1495. X    schach("info",ptr);    /* Info holen        */
  1496. X    modus = atoi(ptr[9]);    /* merken        */
  1497. X    farbe = ptr[0][0];
  1498. X    level = atoi(ptr[6]);
  1499. X
  1500. X
  1501. X    ad_menu();        /* Menue ausgeben    */
  1502. X
  1503. X    move(23,79);        /* Cursor weg        */
  1504. }
  1505. X
  1506. /****************************************************************/
  1507. /*    Partie loeschen                        */
  1508. /****************************************************************/
  1509. X
  1510. void    ad_remove()
  1511. {
  1512. X    char    str[STRLEN*2];
  1513. X
  1514. X    if(stdname[0]=='\0')    /* Kein Name definiert ?    */
  1515. X        return;
  1516. X
  1517. X    sprintf(str,"%s/%s.ch",WORKDIR,stdname);
  1518. X    unlink(str);
  1519. X
  1520. X    sprintf(str,"%s/%s.lock",WORKDIR,stdname);
  1521. X    unlink(str);
  1522. }
  1523. SHAR_EOF
  1524. chmod 0644 ad/init.c ||
  1525. echo 'restore of ad/init.c failed'
  1526. Wc_c="`wc -c < 'ad/init.c'`"
  1527. test 4435 -eq "$Wc_c" ||
  1528.     echo 'ad/init.c: original size 4435, current size' "$Wc_c"
  1529. rm -f _shar_wnt_.tmp
  1530. fi
  1531. # ============= ad/utility.c ==============
  1532. if test -f 'ad/utility.c' -a X"$1" != X"-c"; then
  1533.     echo 'x - skipping ad/utility.c (File already exists)'
  1534.     rm -f _shar_wnt_.tmp
  1535. else
  1536. > _shar_wnt_.tmp
  1537. echo 'x - extracting ad/utility.c (Text)'
  1538. sed 's/^X//' << 'SHAR_EOF' > 'ad/utility.c' &&
  1539. /****************************************************************/
  1540. /*                                */
  1541. /*    XChess V2.7 Adapter: Curses                */
  1542. /*                                */
  1543. /*    (c) 1991 by Marc Laukien                */
  1544. /*                                */
  1545. /*    Programmteil:    Utilities                */
  1546. /*                                */
  1547. /****************************************************************/
  1548. X
  1549. #include <curses.h>
  1550. #include <stdio.h>
  1551. #include <ctype.h>
  1552. #include <signal.h>
  1553. #include <fcntl.h>
  1554. #include <pwd.h>
  1555. #include "ad.h"
  1556. X
  1557. static char ad_convert();    /* Vorwaerstdeklaration        */
  1558. X
  1559. /****************************************************************/
  1560. /*    Brett aufbauen                        */
  1561. /****************************************************************/
  1562. X
  1563. void    ad_brett()
  1564. X
  1565. {
  1566. X    int    x=0,y=0;        /* Koordinaten    */
  1567. X    int    ch;
  1568. X    int    i;
  1569. X    static    char fig[]="KDTTLLSSBBBBBBBB";    /* Figuren    */
  1570. X    int    wfig[16];            /* schw. Fig.    */
  1571. X    int    sfig[16];            /* wei. Fig    */
  1572. X
  1573. X    schach("brett",ptr);        /* ausfuehren    */
  1574. X
  1575. X    for(i=0;i<16;i++)        /* loeschen    */
  1576. X    {
  1577. X        wfig[i]=(int)ad_convert(tolower(fig[i]))|A_BOLD;
  1578. X        sfig[i]=(int)ad_convert(fig[i])|A_REVERSE;
  1579. X    }
  1580. X
  1581. X    for(y=0;y<8;y++)        /* Koordinaten durchgehen    */
  1582. X    for(x=0;x<8;x++)
  1583. X    {
  1584. X        ch=(int)ant[y][x*2];
  1585. X
  1586. X        if(islower(ch))            /* weiss ?    */
  1587. X        {
  1588. X            for(i=0;i<16;i++)    /* durchsuchen    */
  1589. X                if((char)wfig[i]==ad_convert((char)ch))
  1590. X                {        /* eintragen    */
  1591. X                    wfig[i]=(int)ad_convert('.');
  1592. X                    break;
  1593. X                }
  1594. X
  1595. X            ch = (int)ad_convert((char)ch)|A_BOLD;
  1596. X                        /* hell        */
  1597. X        }
  1598. X        else if(isupper(ch))        /* schwarz ?    */
  1599. X        {
  1600. X            for(i=0;i<16;i++)    /* durchsuchen    */
  1601. X                if((char)sfig[i]==ad_convert((char)ch))
  1602. X                {        /* eintragen    */
  1603. X                    sfig[i]=(int)ad_convert('.');
  1604. X                    break;
  1605. X                }
  1606. X
  1607. X            ch = (int)ad_convert((char)ch)|A_REVERSE;
  1608. X                        /* invers    */
  1609. X        }
  1610. X        else if(ch==(int)'.')        /* leer ?    */
  1611. X        {
  1612. X            ch = (int)ad_convert((char)ch);
  1613. X            if(!(x%2 ^ y%2))    /* schwarzes Feld ?    */
  1614. X                ch |= A_REVERSE|A_BOLD;
  1615. X            else
  1616. X                ch |= A_BOLD;
  1617. X        }
  1618. X
  1619. X        mvaddch(y*3+1,x*5+3,ch);    /* eintragen    */
  1620. X    }
  1621. X
  1622. X    move(20,8*5+3);        /* geschl. schw. Fig ausgeben    */
  1623. X    for(i=0;i<16;i++)
  1624. X    {
  1625. X        addch(sfig[i]);
  1626. X        addch((int)' ');
  1627. X    }
  1628. X    move(21,8*5+3);        /* geschl. weisse Fig ausgeben    */
  1629. X    for(i=0;i<16;i++)
  1630. X    {
  1631. X        addch(wfig[i]);
  1632. X        addch((int)' ');
  1633. X    }
  1634. X
  1635. X    ad_status();        /* Status ausgeben    */
  1636. }
  1637. X
  1638. static char ad_convert(ch)    /* Figur umwandeln    */
  1639. X
  1640. char ch;
  1641. {
  1642. X    char ret;
  1643. X
  1644. X    ret=ch;            /* Returnwert    */
  1645. X
  1646. X    switch(ch)
  1647. X    {
  1648. X    case 'b':        /* Bauer    */
  1649. X        ret=figtab[0];
  1650. X        break;
  1651. X    case 's':        /* Springer    */
  1652. X        ret=figtab[1];
  1653. X        break;
  1654. X    case 'l':        /* Laeufer    */
  1655. X        ret=figtab[2];
  1656. X        break;
  1657. X    case 't':        /* Turm        */
  1658. X        ret=figtab[3];
  1659. X        break;
  1660. X    case 'd':        /* Dame        */
  1661. X        ret=figtab[4];
  1662. X        break;
  1663. X    case 'k':        /* Koenig    */
  1664. X        ret=figtab[5];
  1665. X        break;
  1666. X    case 'B':        /* Bauer    */
  1667. X        ret=figtab[6];
  1668. X        break;
  1669. X    case 'S':        /* Springer    */
  1670. X        ret=figtab[7];
  1671. X        break;
  1672. X    case 'L':        /* Laeufer    */
  1673. X        ret=figtab[8];
  1674. X        break;
  1675. X    case 'T':        /* Turm        */
  1676. X        ret=figtab[9];
  1677. X        break;
  1678. X    case 'D':        /* Dame        */
  1679. X        ret=figtab[10];
  1680. X        break;
  1681. X    case 'K':        /* Koenig    */
  1682. X        ret=figtab[11];
  1683. X        break;
  1684. X    case '.':        /* Koenig    */
  1685. X        ret=figtab[12];
  1686. X        break;
  1687. X    }
  1688. X
  1689. X    return(ret);
  1690. }
  1691. X
  1692. /****************************************************************/
  1693. /*    Status ausgeben                        */
  1694. /****************************************************************/
  1695. X
  1696. void    ad_status()
  1697. X
  1698. {
  1699. X    int  i;
  1700. X
  1701. X    attrset(0);        /* Alle Attribute aus    */
  1702. X
  1703. X    schach("status",ptr);    /* ausfuehren        */
  1704. X    ende=0;
  1705. X    move(3,MPOS);
  1706. X
  1707. X    if(!strcmp(ptr[0],"p"))    /* Patt            */
  1708. X    {
  1709. X        addstr(patt);
  1710. X        ende=PATT;
  1711. X    }
  1712. X    else if(!strcmp(ptr[0],"r"))    /* Remis        */
  1713. X    {
  1714. X        addstr(patt);
  1715. X        ende=PATT;
  1716. X    }
  1717. X    else if(!strcmp(ptr[0],"mw"))    /* Matt Weiss        */
  1718. X    {
  1719. X        addstr(w_mate);
  1720. X        ende=W_MATT;
  1721. X    }
  1722. X    else if(!strcmp(ptr[0],"ms"))    /* Matt Schwarz        */
  1723. X    {
  1724. X        addstr(b_mate);
  1725. X        ende=S_MATT;
  1726. X    }
  1727. X    else if(!strcmp(ptr[0],"w"))    /* Schach Weiss        */
  1728. X        addstr(w_chess);
  1729. X    else if(!strcmp(ptr[0],"s"))    /* Schach Schwarz    */
  1730. X        addstr(b_chess);
  1731. X    else if(!strcmp(ptr[0],"3"))    /* Dreifache Wiederholung    */
  1732. X    {
  1733. X        addstr(remis_3);
  1734. X        ende=1;
  1735. X    }
  1736. X
  1737. X    for(i=stdscr->_curx;i<79;i++)    /* Rest der Zeile loeschen    */
  1738. X        mvaddch(stdscr->_cury,i,(int)' ');
  1739. X
  1740. X    move(23,79);
  1741. }
  1742. X
  1743. /****************************************************************/
  1744. /*    Eigenes read()                        */
  1745. /****************************************************************/
  1746. X
  1747. int    ad_read(fd,buf,num)
  1748. X
  1749. int    fd;    /* Filedeskriptor    */
  1750. char    *buf;    /* Buffer        */
  1751. int    num;    /* Anzahl der Zeichen    */
  1752. X
  1753. {
  1754. X    int ret;    /* Returnwert    */
  1755. X
  1756. X    do
  1757. X    {
  1758. X        inter=0;        /* Interrupt ruecksetzen    */
  1759. X        ret=read(fd,buf,num);    /* Zeichen lesen           */
  1760. X    } while(inter==1);
  1761. X
  1762. X    return(ret);
  1763. }
  1764. X
  1765. /****************************************************************/
  1766. /*    Eingabebuffer leeren                    */
  1767. /****************************************************************/
  1768. X
  1769. void    ad_flush()
  1770. {
  1771. X    int     flags;                /* Flags fuer read()     */
  1772. X    char    c;
  1773. X
  1774. X    flags=fcntl(0,F_GETFL,0);        /* flags retten     */
  1775. X
  1776. X    /* Buffer leeren    */
  1777. X    fcntl(0,F_SETFL,flags | O_NDELAY);    /* blockierung aus     */
  1778. X    while(read(0,&c,1));            /* Zeichen lesen       */
  1779. X    fcntl(0,F_SETFL,flags & ~O_NDELAY);    /* blockierung ein     */
  1780. }
  1781. SHAR_EOF
  1782. chmod 0644 ad/utility.c ||
  1783. echo 'restore of ad/utility.c failed'
  1784. Wc_c="`wc -c < 'ad/utility.c'`"
  1785. test 4819 -eq "$Wc_c" ||
  1786.     echo 'ad/utility.c: original size 4819, current size' "$Wc_c"
  1787. rm -f _shar_wnt_.tmp
  1788. fi
  1789. # ============= ad/monitor.c ==============
  1790. if test -f 'ad/monitor.c' -a X"$1" != X"-c"; then
  1791.     echo 'x - skipping ad/monitor.c (File already exists)'
  1792.     rm -f _shar_wnt_.tmp
  1793. else
  1794. > _shar_wnt_.tmp
  1795. echo 'x - extracting ad/monitor.c (Text)'
  1796. sed 's/^X//' << 'SHAR_EOF' > 'ad/monitor.c' &&
  1797. /****************************************************************/
  1798. /*                                */
  1799. /*    XChess V2.7 Adapter: Curses                */
  1800. /*                                */
  1801. /*    (c) 1991 by Marc Laukien                */
  1802. /*                                */
  1803. /*    Programmteil:    Analyse                    */
  1804. /*                                */
  1805. /****************************************************************/
  1806. X
  1807. #include <curses.h>
  1808. #include "ad.h"
  1809. X
  1810. /****************************************************************/
  1811. /*    Analyse ausgeben                    */
  1812. /****************************************************************/
  1813. X
  1814. void ad_analyse(str)
  1815. X
  1816. char *str;
  1817. {
  1818. X    int    i;
  1819. X
  1820. X    move(23,0);            /* an die Ausgabestelle gehen    */
  1821. X    attrset(A_REVERSE);
  1822. X    addstr(str);            /* ausgeben    */
  1823. X    attrset(0);
  1824. X    for(i=0+strlen(str);i<79;i++)    /* loeschen    */
  1825. X        addch((int)' '|A_REVERSE);
  1826. X    refresh();            /* ausgeben    */
  1827. }
  1828. SHAR_EOF
  1829. chmod 0644 ad/monitor.c ||
  1830. echo 'restore of ad/monitor.c failed'
  1831. Wc_c="`wc -c < 'ad/monitor.c'`"
  1832. test 752 -eq "$Wc_c" ||
  1833.     echo 'ad/monitor.c: original size 752, current size' "$Wc_c"
  1834. rm -f _shar_wnt_.tmp
  1835. fi
  1836. # ============= ad/window.c ==============
  1837. if test -f 'ad/window.c' -a X"$1" != X"-c"; then
  1838.     echo 'x - skipping ad/window.c (File already exists)'
  1839.     rm -f _shar_wnt_.tmp
  1840. else
  1841. > _shar_wnt_.tmp
  1842. echo 'x - extracting ad/window.c (Text)'
  1843. sed 's/^X//' << 'SHAR_EOF' > 'ad/window.c' &&
  1844. /****************************************************************/
  1845. /*                                */
  1846. /*    XChess V2.7 Adapter: Curses                */
  1847. /*                                */
  1848. /*    (c) 1991 by Marc Laukien                */
  1849. /*                                */
  1850. /*    Programmteil:    Windows                    */
  1851. /*                                */
  1852. /****************************************************************/
  1853. X
  1854. #include <curses.h>
  1855. #include <stdio.h>
  1856. #include <ctype.h>
  1857. #include <string.h>
  1858. #include "ad.h"
  1859. X
  1860. /****************************************************************/
  1861. /*    info ausgeben                        */
  1862. /****************************************************************/
  1863. X
  1864. void    ad_info()
  1865. X
  1866. {
  1867. X    char    str[STRLEN];        /* String        */
  1868. X    int     l=2;            /* Zeile        */
  1869. X    int     nr=0;            /* Ausgabe Nummer    */
  1870. X    char    c;
  1871. X
  1872. X    schach("info",ptr);        /* ausfuehren        */
  1873. X
  1874. X    win=newwin(15,35,4,3);        /* neues Window        */
  1875. X    box(win,0,0);            /* mit Rahmen        */
  1876. X
  1877. X    farbe=ptr[nr][0];        /* FARBE        */
  1878. X    sprintf(str,"%s%s",info[0],ptr[nr++][0]=='w'?white:black);
  1879. X    wmove(win,l++,2);        /* positionieren    */
  1880. X    waddstr(win,str);        /* ausgeben        */
  1881. X
  1882. X    sprintf(str,"%s%s",info[1],ptr[nr++]);    /* ZUEGE    */
  1883. X    wmove(win,l++,2);        /* positionieren    */
  1884. X    waddstr(win,str);        /* ausgeben        */
  1885. X
  1886. X    sprintf(str,"%s%s",info[2],ptr[nr++]);    /* WERTUNG    */
  1887. X    wmove(win,l++,2);        /* positionieren    */
  1888. X    waddstr(win,str);        /* ausgeben        */
  1889. X
  1890. X    sprintf(str,"%s%s",info[3],ptr[nr++]);    /* VARIANTEN    */
  1891. X    wmove(win,l++,2);        /* positionieren    */
  1892. X    waddstr(win,str);        /* ausgeben        */
  1893. X
  1894. X    sprintf(str,"%s%s",info[4],ptr[nr++]);    /* VAR/SEK    */
  1895. X    wmove(win,l++,2);        /* positionieren    */
  1896. X    waddstr(win,str);        /* ausgeben        */
  1897. X
  1898. X    sprintf(str,"%s%s",info[5],ptr[nr++]);    /* DURCHSCHNITT    */
  1899. X    wmove(win,l++,2);        /* positionieren    */
  1900. X    waddstr(win,str);        /* ausgeben        */
  1901. X
  1902. X    sprintf(str,"%s%d",info[6],atoi(ptr[nr++])+1);    /* STUFE*/
  1903. X    wmove(win,l++,2);        /* positionieren    */
  1904. X    waddstr(win,str);        /* ausgeben        */
  1905. X
  1906. X    sprintf(str,"%s%s",info[7],ptr[nr++]);    /* TIEFE MIN    */
  1907. X    wmove(win,l++,2);        /* positionieren    */
  1908. X    waddstr(win,str);        /* ausgeben        */
  1909. X
  1910. X    sprintf(str,"%s%s",info[8],ptr[nr++]);    /* TIEFE MAX    */
  1911. X    wmove(win,l++,2);        /* positionieren    */
  1912. X    waddstr(win,str);        /* ausgeben        */
  1913. X
  1914. X    nr++;            /* MODE wird nicht benoetigt    */
  1915. X
  1916. X    sprintf(str,"%s%s",info[9],ptr[nr++]);    /* LETZTER ZUG    */
  1917. X    wmove(win,l++,2);        /* positionieren    */
  1918. X    waddstr(win,str);        /* ausgeben        */
  1919. X
  1920. X    wmove(win,l++,2);        /* positionieren    */
  1921. X    waddstr(win,press_key);        /* TASTE        */
  1922. X    wrefresh(win);            /* ausgeben        */
  1923. X    move(23,79);
  1924. X    refresh();
  1925. X
  1926. X    ad_read(0,&c,1);        /* auf Taste warten    */
  1927. X
  1928. X    delwin(win);            /* Fenster aus        */
  1929. X    win=(WINDOW *)0;
  1930. X    touchwin(stdscr);
  1931. }
  1932. X
  1933. /****************************************************************/
  1934. /*    Filenamen/Gegnernamen einlesen                */
  1935. /****************************************************************/
  1936. X
  1937. char     *ad_name(mode)
  1938. X
  1939. char    mode;    /* f = Filename        g = Gegner    */
  1940. {
  1941. X    char     str[STRLEN];        /* String        */
  1942. X    static    char s[STRLEN];        /* Return-String    */
  1943. X    char     c;            /* Zeichen        */
  1944. X    int     i=0;
  1945. X
  1946. X    if(mode!='g' && mode !='f')    /* Fehler ?        */
  1947. X        return("");
  1948. X
  1949. X    win=newwin(3,60,10,10);        /* neues Window        */
  1950. X    box(win,0,0);            /* mit Rahmen        */
  1951. X    wmove(win,1,1);
  1952. X    waddstr(win,mode=='f' ? enter:opponent);
  1953. X    wmove(win,1,1+strlen(mode=='f' ? enter:opponent));
  1954. X
  1955. X    str[i]=0;            /* loeschen        */
  1956. X
  1957. X        do
  1958. X    {
  1959. X        wrefresh(win);        /* ausgeben        */
  1960. X        ad_read(0,&c,1);    /* Zeichen einlesen    */
  1961. X
  1962. X        if(c=='\b' && i>0)    /* Backspace    */
  1963. X        {
  1964. X            waddstr(win,"\b \b");
  1965. X            str[--i]=0;
  1966. X        }
  1967. X
  1968. X        if(c==127)        /* Delete    */
  1969. X            while(i>0)
  1970. X            {
  1971. X                waddstr(win,"\b \b");
  1972. X                str[--i]=0;
  1973. X            }
  1974. X
  1975. X        if(isprint(c) &&
  1976. X        (mode == 'f' ? i<5 : i<57-strlen(opponent))
  1977. X        && c!='/' && c!='.' && c!=' ')
  1978. X        {
  1979. X            waddch(win,(int)c);    /* ausgeben    */
  1980. X            str[i]=c;
  1981. X            str[++i]=0;
  1982. X        }
  1983. X    }
  1984. X    while(c!='\n' && c!=(char)13);
  1985. X    
  1986. X    wrefresh(win);            /* ausgeben        */
  1987. X    delwin(win);            /* Fenster aus        */
  1988. X    win=(WINDOW *)0;
  1989. X
  1990. X    move(23,79);
  1991. X    touchwin(stdscr);
  1992. X    wnoutrefresh(stdscr);
  1993. X    if(setupwin != (WINDOW *)0)
  1994. X    {
  1995. X        touchwin(setupwin);
  1996. X        wnoutrefresh(setupwin);
  1997. X    }
  1998. X    doupdate();
  1999. X
  2000. X    if(mode=='f')
  2001. X    {
  2002. X        sprintf(s,"training/%s.",ad_id(getlogin()));
  2003. X                    /* Pfad dazu        */
  2004. X        strcat(s,str);
  2005. X    }
  2006. X    else
  2007. X        strcpy(s,str);        /* ohne Pfad        */
  2008. X
  2009. X    return(s);
  2010. }
  2011. X
  2012. /****************************************************************/
  2013. /*    Fehlermeldung                        */
  2014. /****************************************************************/
  2015. X
  2016. void    ad_error(s)
  2017. X
  2018. char     *s;
  2019. {
  2020. X    char str[STRLEN];        /* String        */
  2021. X    char c;
  2022. X
  2023. X    if(curses)            /* Curses an ?        */
  2024. X    {
  2025. X        if(s[0]==0)        /* externer Fehler ?    */
  2026. X            sprintf(str,"%s%s",error,sys_errlist[errno]);
  2027. X        else            /* interner Fehler ?    */
  2028. X            sprintf(str,"%s%s",error,s);
  2029. X
  2030. X        win=newwin(3,60,10,10);    /* neues Window        */
  2031. X        box(win,0,0);        /* mit Rahmen        */
  2032. X        wmove(win,1,1);
  2033. X        waddstr(win,str);
  2034. X        wmove(win,1,59-strlen(press_key));
  2035. X        waddstr(win,press_key);
  2036. X
  2037. X        refresh();
  2038. X        wrefresh(win);        /* ausgeben        */
  2039. X        move(23,79);
  2040. X        refresh();
  2041. X
  2042. X        ad_read(0,&c,1);        /* auf Taste warten    */
  2043. X
  2044. X        delwin(win);        /* Fenster aus        */
  2045. X        win=(WINDOW *)0;
  2046. X
  2047. X        move(23,79);
  2048. X        touchwin(stdscr);
  2049. X        wnoutrefresh(stdscr);
  2050. X        if(setupwin != (WINDOW *)0)
  2051. X        {
  2052. X            touchwin(setupwin);
  2053. X            wnoutrefresh(setupwin);
  2054. X        }
  2055. X        doupdate();
  2056. X    }
  2057. X    else
  2058. X        fprintf(stderr,"%s: %s\n",pname,sys_errlist[errno]);
  2059. }
  2060. X
  2061. /****************************************************************/
  2062. /*    Meldung                            */
  2063. /****************************************************************/
  2064. X
  2065. void    ad_msg(s)
  2066. X
  2067. char     *s;
  2068. {
  2069. X    int     i;
  2070. X
  2071. X    win=newwin(2,80,22,0);    /* neues Window        */
  2072. X    wmove(win,0,0);
  2073. X    for(i=0;i<80;i++)    /* Linie        */
  2074. X        waddch(win,(int)'-');
  2075. X
  2076. X    wmove(win,1,39-strlen(s)/2);
  2077. X    waddstr(win,s);
  2078. X
  2079. X    refresh();
  2080. X    wrefresh(win);        /* ausgeben        */
  2081. X    move(23,79);
  2082. X    refresh();
  2083. X
  2084. X    delwin(win);        /* Fenster aus        */
  2085. X    win=(WINDOW *)0;
  2086. X
  2087. X    move(23,79);
  2088. X    touchwin(stdscr);
  2089. X    wnoutrefresh(stdscr);
  2090. X    if(setupwin != (WINDOW *)0)
  2091. X    {
  2092. X        touchwin(setupwin);
  2093. X        wnoutrefresh(setupwin);
  2094. X    }
  2095. }
  2096. X
  2097. /****************************************************************/
  2098. /*    Sicherheitsabfrage                    */
  2099. /****************************************************************/
  2100. /*    Return: 0-nein    1-ja                    */
  2101. /****************************************************************/
  2102. X
  2103. int    ad_sure(mode)
  2104. X
  2105. char    mode;    /* s = Sicher ?        a = Aufgeben ?        */
  2106. {
  2107. X    char     c;            /* Zeichen        */
  2108. X    char    *str;
  2109. X
  2110. X    if(mode=='s')
  2111. X        str=sure;
  2112. X    else if(mode=='a')
  2113. X        str=give_up;
  2114. X    else
  2115. X        return(0);
  2116. X
  2117. X    win=newwin(3,60,10,10);        /* neues Window        */
  2118. X    box(win,0,0);            /* mit Rahmen        */
  2119. X    wmove(win,1,1+(58-strlen(str+2))/2);
  2120. X    waddstr(win,str+2);
  2121. X
  2122. X    wrefresh(win);            /* ausgeben        */
  2123. X    move(23,79);
  2124. X    refresh();
  2125. X
  2126. X    do
  2127. X    {
  2128. X        ad_read(0,&c,1);    /* auf Taste warten    */
  2129. X
  2130. X        if(isupper(c))        /* klein machen        */
  2131. X            c=tolower(c);
  2132. X
  2133. X        if(c!=str[0] && c!=str[1])
  2134. SHAR_EOF
  2135. true || echo 'restore of ad/window.c failed'
  2136. fi
  2137. echo 'End of UnixChess part 2'
  2138. echo 'File ad/window.c is continued in part 3'
  2139. echo 3 > _shar_seq_.tmp
  2140. exit 0
  2141. -- 
  2142.    /              |    -: Marc Laukien :-     |
  2143.   /__             |                           |   _  _           __
  2144.  /   \  /_  /  /  |   ml@brumuc.muc.sub.org   |  / \/ |   /  /  /
  2145. /____/ /   /__/   | sigma@salyko.doit.sub.org | /     |  /__/  /__
  2146.