home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 3 / 3382 < prev    next >
Internet Message Format  |  1991-05-20  |  51KB
  1. From: ml@brumuc.muc.sub.org (Marc Laukien)
  2. Newsgroups: alt.sources
  3. Subject: UnixChess03/10
  4. Message-ID: <1991May20.003124.6306@brumuc.muc.sub.org>
  5. Date: 20 May 91 00:31:24 GMT
  6.  
  7. Submitted-by: ml@brumuc.muc.sub.org
  8. Archive-name: UnixChess/part03
  9.  
  10. ---- Cut Here and feed the following to sh ----
  11. #!/bin/sh
  12. # this is chess.03 (part 3 of UnixChess)
  13. # do not concatenate these parts, unpack them in order with /bin/sh
  14. # file ad/window.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" != 3; 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 ad/window.c'
  30. else
  31. echo 'x - continuing file ad/window.c'
  32. sed 's/^X//' << 'SHAR_EOF' >> 'ad/window.c' &&
  33. X            beep();
  34. X    }
  35. X    while(c!=str[0] && c!=str[1]);
  36. X
  37. X    delwin(win);            /* Fenster aus        */
  38. X    win=(WINDOW *)0;
  39. X
  40. X    move(23,79);
  41. X    touchwin(stdscr);
  42. X    wnoutrefresh(stdscr);
  43. X    if(setupwin != (WINDOW *)0)
  44. X    {
  45. X        touchwin(setupwin);
  46. X        wnoutrefresh(setupwin);
  47. X    }
  48. X    doupdate();
  49. X
  50. X    if(c==str[0])            /* ja ?            */
  51. X        return(1);
  52. X    else                /* nein ?        */
  53. X        return(0);
  54. }
  55. X
  56. X
  57. SHAR_EOF
  58. echo 'File ad/window.c is complete' &&
  59. chmod 0644 ad/window.c ||
  60. echo 'restore of ad/window.c failed'
  61. Wc_c="`wc -c < 'ad/window.c'`"
  62. test 6749 -eq "$Wc_c" ||
  63.     echo 'ad/window.c: original size 6749, current size' "$Wc_c"
  64. rm -f _shar_wnt_.tmp
  65. fi
  66. # ============= ad/move.c ==============
  67. if test -f 'ad/move.c' -a X"$1" != X"-c"; then
  68.     echo 'x - skipping ad/move.c (File already exists)'
  69.     rm -f _shar_wnt_.tmp
  70. else
  71. > _shar_wnt_.tmp
  72. echo 'x - extracting ad/move.c (Text)'
  73. sed 's/^X//' << 'SHAR_EOF' > 'ad/move.c' &&
  74. /****************************************************************/
  75. /*                                */
  76. /*    XChess V2.7 Adapter: Curses                */
  77. /*                                */
  78. /*    (c) 1991 by Marc Laukien                */
  79. /*                                */
  80. /*    Programmteil:    Zug ausfuehren                */
  81. /*                                */
  82. /****************************************************************/
  83. X
  84. #include <curses.h>
  85. #include <string.h>
  86. #include "ad.h"
  87. X
  88. extern    unsigned    sleep();
  89. X
  90. /****************************************************************/
  91. /*    Zug ausfuehren                        */
  92. /****************************************************************/
  93. X
  94. void    ad_zug(ch)
  95. X
  96. char     ch;                /* Charakter    */
  97. {
  98. X    char    str[STRLEN];        /* String    */
  99. X    int    i;
  100. X
  101. X    strcpy(str,"ziehe ");        /* aufbereiten    */
  102. X
  103. X    move(16,MPOS);            /* in Position    */
  104. X    addstr(domove);            /* Meldung    */
  105. X    addch(ch|A_UNDERLINE);        /* ausgeben    */
  106. X    sprintf(str+strlen(str),"%c",(char)ch);        /* aufbereiten    */
  107. X    refresh();
  108. X
  109. l1:    ad_read(0,&ch,1);        /* einlesen    */
  110. X    if(ch=='\b')        /* zurueck ?    */
  111. X    {
  112. X        addstr("\b \b");
  113. X        str[strlen(str)-1]=0;
  114. X        refresh();
  115. X        goto l5;
  116. X    }
  117. X    if(ch<(int)'1' || ch>(int)'8')
  118. X    {
  119. X        beep();
  120. X        goto l1;
  121. X    }
  122. X    addch(ch|A_UNDERLINE);    /* ausgeben    */
  123. X    sprintf(str+strlen(str),"%c ",(char)ch);    /* aufbereiten    */
  124. X    addch((int)'-'|A_UNDERLINE);
  125. X    refresh();
  126. X    
  127. l2:    ad_read(0,&ch,1);        /* einlesen    */
  128. X    if(ch=='\b')        /* zurueck ?    */
  129. X    {
  130. X        addstr("\b \b");
  131. X        str[strlen(str)-1]=0;
  132. X        addstr("\b \b");
  133. X        str[strlen(str)-1]=0;
  134. X        refresh();
  135. X        goto l1;
  136. X    }
  137. X    if(ch<(int)'a' || ch>(int)'h')
  138. X    {
  139. X        beep();
  140. X        goto l2;
  141. X    }
  142. X    addch(ch|A_UNDERLINE);    /* ausgeben    */
  143. X    sprintf(str+strlen(str),"%c",(char)ch);        /* aufbereiten    */
  144. X    refresh();
  145. X    
  146. l3:    ad_read(0,&ch,1);        /* einlesen    */
  147. X    if(ch=='\b')        /* zurueck ?    */
  148. X    {
  149. X        addstr("\b \b");
  150. X        str[strlen(str)-1]=0;
  151. X        refresh();
  152. X        goto l2;
  153. X    }
  154. X    if(ch<(int)'1' || ch>(int)'8')
  155. X    {
  156. X        beep();
  157. X        goto l3;
  158. X    }
  159. X    addch(ch|A_UNDERLINE);    /* ausgeben    */
  160. X    sprintf(str+strlen(str),"%c",(char)ch);        /* aufbereiten    */
  161. X    refresh();
  162. X
  163. X    schach(str,ptr);    /* ziehen    */
  164. X    if(ptr[0][0]!='?')    /* zug ok ?    */
  165. X    {
  166. X        ad_brett();
  167. X        farbe= farbe=='w' ? 's':'w';    
  168. X                /* naechste Farbe    */
  169. X    }
  170. X    else            /* falscheingabe    */
  171. X        beep();
  172. X
  173. l5:    move(16,MPOS);        /* in Position    */
  174. X    for(i=MPOS;i<79;i++)    /* loschen    */
  175. X        addstr(" ");
  176. X    refresh();
  177. X
  178. X    if(TURNGEG())
  179. X    {
  180. X        ad_lock();
  181. X        sprintf(str,"save %s",stdname);
  182. X        schach(str,ptr);    /* Speichern        */
  183. X        ad_unlock();
  184. X    }
  185. }
  186. X
  187. /****************************************************************/
  188. /*    externen Zug ausfuehren                    */
  189. /****************************************************************/
  190. X
  191. void    ad_extzug()
  192. {
  193. X    char    s[STRLEN];
  194. X    int    i;
  195. X
  196. X    sleep((unsigned)5);    /* warten        */
  197. X
  198. X    ad_lock();
  199. X    sprintf(s,"load %s",stdname);    /* Pfad zum Laden    */
  200. X    schach(s,ptr);        /* Laden        */
  201. X    ad_unlock();
  202. X
  203. X    if(ptr[0][0]=='?')    /* Fehler ?        */
  204. X    {
  205. X        move(3,MPOS);
  206. X
  207. X        if(W_IS_USER())        /* Schwarz gab auf    */
  208. X        {
  209. X            attrset(0);    /* Alle Attribute aus    */
  210. X            addstr(b_up);    /* Meldung        */
  211. X
  212. X            ende=S_AUFG;
  213. X        }
  214. X
  215. X        if(B_IS_USER())        /* Weiss gab auf    */
  216. X        {
  217. X            attrset(0);    /* Alle Attribute aus    */
  218. X            addstr(w_up);    /* Meldung        */
  219. X
  220. X            ende=W_AUFG;
  221. X        }
  222. X
  223. X        for(i=stdscr->_curx;i<79;i++)    /* Rest der Zeile loeschen*/
  224. X            mvaddch(stdscr->_cury,i,(int)' ');
  225. X
  226. X    }
  227. X    else
  228. X    {
  229. X        ad_brett();        /* Brett aufbauen    */
  230. X
  231. X        schach("info",ptr);    /* Info holen        */
  232. X        modus = atoi(ptr[9]);    /* merken        */
  233. X        farbe = ptr[0][0];
  234. X        level = atoi(ptr[6]);
  235. X
  236. X        ad_menu();
  237. X    }
  238. }
  239. SHAR_EOF
  240. chmod 0644 ad/move.c ||
  241. echo 'restore of ad/move.c failed'
  242. Wc_c="`wc -c < 'ad/move.c'`"
  243. test 3257 -eq "$Wc_c" ||
  244.     echo 'ad/move.c: original size 3257, current size' "$Wc_c"
  245. rm -f _shar_wnt_.tmp
  246. fi
  247. # ============= ad/interrupt.c ==============
  248. if test -f 'ad/interrupt.c' -a X"$1" != X"-c"; then
  249.     echo 'x - skipping ad/interrupt.c (File already exists)'
  250.     rm -f _shar_wnt_.tmp
  251. else
  252. > _shar_wnt_.tmp
  253. echo 'x - extracting ad/interrupt.c (Text)'
  254. sed 's/^X//' << 'SHAR_EOF' > 'ad/interrupt.c' &&
  255. /****************************************************************/
  256. /*                                */
  257. /*    XChess V2.7 Adapter: Curses                */
  258. /*                                */
  259. /*    (c) 1991 by Marc Laukien                */
  260. /*                                */
  261. /*    Programmteil:    Interrupts                */
  262. /*                                */
  263. /****************************************************************/
  264. X
  265. #include <curses.h>
  266. #include <stdio.h>
  267. #include <signal.h>
  268. #include "ad.h"
  269. X
  270. extern    void    exit();
  271. X
  272. /****************************************************************/
  273. /*    Interrupt                        */
  274. /****************************************************************/
  275. X
  276. void    ad_interrupt()
  277. X
  278. {
  279. X    inter=1;
  280. X
  281. X    ad_deinit();            /* Deinitialsieren    */
  282. X    exit(1);            /* Ende            */
  283. }
  284. X
  285. /****************************************************************/
  286. /*    Refresh     (^ L)                        */
  287. /****************************************************************/
  288. X
  289. void    ad_refresh()
  290. X
  291. {
  292. X    WINDOW    *dwin;        /* neues Fenster    */
  293. X
  294. X    signal(SIGUSR1,SIG_IGN);
  295. X    signal(SIGALRM,SIG_IGN);
  296. X
  297. X    inter=1;        /* Interrupt merken    */
  298. X
  299. X    dwin=newwin(LINES,COLS,0,0);
  300. X    wnoutrefresh(dwin);        /* ausgeben        */
  301. X    delwin(dwin);        /* Fenster aus        */
  302. X
  303. X    touchwin(stdscr);    /* Fenster ausgeben    */
  304. X    wnoutrefresh(stdscr);
  305. X    if(win != (WINDOW *)0)
  306. X    {
  307. X        touchwin(win);
  308. X        wnoutrefresh(win);
  309. X    }
  310. X
  311. X    if(setupwin != (WINDOW *)0)
  312. X    {
  313. X        touchwin(setupwin);
  314. X        wnoutrefresh(setupwin);
  315. X    }
  316. X
  317. X    doupdate();
  318. X
  319. X    move(23,79);
  320. X    refresh();
  321. X
  322. X    signal(SIGUSR1,ad_refresh);
  323. }
  324. X
  325. /****************************************************************/
  326. /*    "Best so far"                        */
  327. /****************************************************************/
  328. X
  329. void    ad_break()
  330. X
  331. {
  332. X    extern    int beende;    /* aus ch_ma.c    */
  333. X
  334. X    inter=1;        /* Interrupt merken    */
  335. X
  336. X    signal(SIGUSR2,SIG_IGN);
  337. X
  338. X    if(UEBUNG())
  339. X        beende=1;    /* beenden    */
  340. X
  341. X    signal(SIGUSR2,ad_break);
  342. }
  343. X
  344. /****************************************************************/
  345. /*    Interrupt starten                    */
  346. /****************************************************************/
  347. X
  348. void    ad_startint()
  349. {
  350. X    signal(SIGINT,ad_interrupt);    /* Interrupt aendern    */
  351. X    signal(SIGTERM,ad_interrupt);
  352. X    signal(SIGHUP,ad_interrupt);
  353. X
  354. X    signal(SIGUSR1,ad_refresh);    /* Bild neu aufb. (^ L)    */
  355. X    signal(SIGUSR2,ad_break);    /* "Best so far"    */
  356. }
  357. SHAR_EOF
  358. chmod 0644 ad/interrupt.c ||
  359. echo 'restore of ad/interrupt.c failed'
  360. Wc_c="`wc -c < 'ad/interrupt.c'`"
  361. test 2103 -eq "$Wc_c" ||
  362.     echo 'ad/interrupt.c: original size 2103, current size' "$Wc_c"
  363. rm -f _shar_wnt_.tmp
  364. fi
  365. # ============= ad/load.c ==============
  366. if test -f 'ad/load.c' -a X"$1" != X"-c"; then
  367.     echo 'x - skipping ad/load.c (File already exists)'
  368.     rm -f _shar_wnt_.tmp
  369. else
  370. > _shar_wnt_.tmp
  371. echo 'x - extracting ad/load.c (Text)'
  372. sed 's/^X//' << 'SHAR_EOF' > 'ad/load.c' &&
  373. /****************************************************************/
  374. /*                                */
  375. /*    XChess V2.7 Adapter: Curses                */
  376. /*                                */
  377. /*    (c) 1991 by Marc Laukien                */
  378. /*                                */
  379. /*    Programmteil:    Laden & Speichern & Neustart        */
  380. /*                                */
  381. /****************************************************************/
  382. X
  383. #include <curses.h>
  384. #include <stdio.h>
  385. #include <string.h>
  386. #include "ad.h"
  387. X
  388. /****************************************************************/
  389. /*    Programm Laden                        */
  390. /****************************************************************/
  391. X
  392. void    ad_load()
  393. X
  394. {
  395. X    char     str[STRLEN];
  396. X    char    *s;
  397. X
  398. X    if(TURNIER())    /* Turnierspiel ?    */
  399. X    {
  400. X        ad_error(not_allowed);
  401. X        return;
  402. X    }
  403. X
  404. X    s=ad_name('f');
  405. X    if(s[strlen(s)-1] != '/')
  406. X    if(ad_sure('s'))
  407. X    {
  408. X        sprintf(str,"load %s",s);
  409. X        schach(str,ptr);
  410. X
  411. X        if(ptr[0][0]=='?')    /* Fehler ?    */
  412. X            ad_error("");
  413. X        else
  414. X        {
  415. X            ad_brett();
  416. X
  417. X            schach("info",ptr);/* Info hol.    */
  418. X            farbe=ptr[0][0];/* Farbe am Zug    */
  419. X            if(farbe=='w')    /* Farbe einst.    */
  420. X            {
  421. X                wei=0;
  422. X                sch=1;
  423. X            }
  424. X            else
  425. X            {
  426. X                sch=0;
  427. X                wei=1;
  428. X            }
  429. X            level=atoi(ptr[6]);/* Spielstufe*/
  430. X            modus=atoi(ptr[9]);/* Modus    */
  431. X            ad_menu();
  432. X        }
  433. X    }
  434. }
  435. X
  436. /****************************************************************/
  437. /*    Programm speichern                    */
  438. /****************************************************************/
  439. X
  440. void    ad_save()
  441. X
  442. {
  443. X    char     str[STRLEN];
  444. X    char    *s;
  445. X
  446. X    if(TURNIER())    /* Turnierspiel ?    */
  447. X    {
  448. X        ad_error(not_allowed);
  449. X        return;
  450. X    }
  451. X
  452. X    s=ad_name('f');
  453. X    if(s[strlen(s)-1] != '/')
  454. X    {
  455. X        sprintf(str,"save %s",s);
  456. X        schach(str,ptr);
  457. X        if(ptr[0][0]=='?')    /* Fehler ?    */
  458. X        ad_error("");
  459. X    }
  460. }
  461. X
  462. /****************************************************************/
  463. /*    Zurueck                            */
  464. /****************************************************************/
  465. X
  466. void    ad_zurueck()
  467. X
  468. {
  469. X    if(TURNIER())    /* Turnierspiel ?    */
  470. X    {
  471. X        ad_error(not_allowed);
  472. X        return;
  473. X    }
  474. X
  475. X    schach("zurueck",ptr);
  476. X    ad_brett();
  477. X    schach("info",ptr);/* Info hol.    */
  478. X    farbe=ptr[0][0];/* Farbe am Zug    */
  479. X
  480. X    if(farbe=='w')    /* Farbe einst.    */
  481. X    {
  482. X        wei=0;
  483. X        sch=1;
  484. X    }
  485. X    else
  486. X    {
  487. X        sch=0;
  488. X        wei=1;
  489. X    }
  490. X    level=atoi(ptr[6]);    /* Spielstufe    */
  491. X    ad_menu();
  492. }
  493. SHAR_EOF
  494. chmod 0644 ad/load.c ||
  495. echo 'restore of ad/load.c failed'
  496. Wc_c="`wc -c < 'ad/load.c'`"
  497. test 2094 -eq "$Wc_c" ||
  498.     echo 'ad/load.c: original size 2094, current size' "$Wc_c"
  499. rm -f _shar_wnt_.tmp
  500. fi
  501. # ============= ad/menu.c ==============
  502. if test -f 'ad/menu.c' -a X"$1" != X"-c"; then
  503.     echo 'x - skipping ad/menu.c (File already exists)'
  504.     rm -f _shar_wnt_.tmp
  505. else
  506. > _shar_wnt_.tmp
  507. echo 'x - extracting ad/menu.c (Text)'
  508. sed 's/^X//' << 'SHAR_EOF' > 'ad/menu.c' &&
  509. /****************************************************************/
  510. /*                                */
  511. /*    XChess V2.7 Adapter: Curses                */
  512. /*                                */
  513. /*    (c) 1991 by Marc Laukien                */
  514. /*                                */
  515. /*    Programmteil:    Spielmenue                */
  516. /*                                */
  517. /****************************************************************/
  518. X
  519. #include <curses.h>
  520. #include <stdio.h>
  521. #include <string.h>
  522. #include <fcntl.h>
  523. #include <ctype.h>
  524. #include <time.h>
  525. #include <sys/types.h>
  526. #include "ad.h"
  527. X
  528. /****************************************************************/
  529. /*    Spielmenue                        */
  530. /****************************************************************/
  531. X
  532. void    ad_game()
  533. X
  534. {
  535. X    char    s[STRLEN];    /* String        */
  536. X
  537. X    if(!UEBUNG())    /* Spiel gegen sich selbst ?    */
  538. X    {
  539. X        strcpy(s,ad_id(gegner));
  540. X        if(!strcmp(s,ad_id(getlogin())))
  541. X            return;
  542. X    }
  543. X
  544. X    if(!UEBUNG() && !strcmp(ad_id(gegner),"?"))
  545. X    {            /* Existiert Gegner ?    */
  546. X        ad_error(no_user);
  547. X        return;
  548. X    }
  549. X
  550. X    ad_game_screen();    /* Bildaufbau        */
  551. X
  552. X    ad_new();        /* neues Spiel        */
  553. X
  554. X    if(UEBUNG())        /* Training ?        */
  555. X        ad_tr_game();
  556. X    else if(TURNGEG())    /* Turnier gegen Gegner ?    */
  557. X        ad_tu_game();
  558. X    else            /* Turnier gegen Computer ?    */
  559. X        ad_tc_game();
  560. }
  561. X
  562. /****************************************************************/
  563. /*    Menueeingabe                        */
  564. /****************************************************************/
  565. /*    Return:    1: ok        0: Ende                */
  566. /*            2: Aufgeben                    */
  567. /****************************************************************/
  568. X
  569. int    ad_domenu(ch)
  570. X
  571. char     ch;
  572. {
  573. X    if(ch<='h' && ch>='a' && !ende &&    /*** ziehen    ***/
  574. X    ((farbe=='w' && W_IS_USER()) || (farbe=='s' && B_IS_USER())))
  575. X        ad_zug(ch);
  576. X    else if(ch==menu[0][0])            /*** Level    ***/
  577. X    {
  578. X        char str[STRLEN];
  579. X
  580. X        if(TURNIER())            /* Turnierspiel    */
  581. X            ad_error(not_allowed);
  582. X        else
  583. X        {
  584. X            level++;
  585. X            if(level >=10)
  586. X                level=0;
  587. X            ad_menu();
  588. X
  589. X            sprintf(str,"stufe %d",level);
  590. X            schach(str,ptr);
  591. X        }
  592. X    }
  593. X    else if(ch==menu[1][0])            /*** Weiss    ***/
  594. X    {
  595. X        if(TURNIER())        /* Turnierspiel ?    */
  596. X            ad_error(not_allowed);
  597. X        else
  598. X        {
  599. X            wei= W_IS_USER();
  600. X            ad_menu();
  601. X        }
  602. X    }
  603. X    else if(ch==menu[2][0])            /*** Schwarz    ***/
  604. X    {
  605. X        if(TURNIER())        /* Turnierspiel ?    */
  606. X            ad_error(not_allowed);
  607. X        else
  608. X        {
  609. X            sch= B_IS_USER();
  610. X            ad_menu();
  611. X        }
  612. X    }
  613. X    else if(ch==menu[3][0])            /*** Analyse    ***/
  614. X    {
  615. X        char    str[STRLEN];
  616. X
  617. X        if(TURNGEG())            /* ext. Gegner    */
  618. X            ad_error(not_allowed);
  619. X        else
  620. X        {
  621. X            schach("info",ptr);    /* Info hol.    */
  622. X            modus=atoi(ptr[9]);    /* Modus    */
  623. X            modus ^= 128;        /* aendern    */
  624. X            sprintf(str,"modus %d",modus);
  625. X            schach(str,ptr);    /* setzen    */
  626. X            if(!(modus & 128))    /* aus ?    */
  627. X            ad_analyse("   a    b    c    d    e    f    g    h");
  628. X            ad_menu();
  629. X        }
  630. X    }
  631. X    else if(ch==menu[4][0])            /*** Setup    ***/
  632. X        ad_setup();
  633. X    else if(ch==menu[5][0])            /*** Zurueck    ***/
  634. X        ad_zurueck();
  635. X    else if(ch==menu[6][0])            /*** Info    ***/
  636. X        ad_info();
  637. X    else if(ch==menu[7][0])            /*** Neustart    ***/
  638. X    {
  639. X        return(2);
  640. X    }
  641. X    else if(ch==menu[8][0])    /*** ende    ***/
  642. X    {
  643. X        if(ad_sure('s'))
  644. X            return(0);
  645. X    }
  646. #ifdef EXT_ANALYSE                    /* gesperrt !    */
  647. X    else if(ch==(char)26)            /*** ausf. Analyse ***/
  648. X    {                    /* ^ Z        */
  649. X        char    str[STRLEN];
  650. X
  651. X        schach("info",ptr);        /* Info hol.    */
  652. X        modus=atoi(ptr[9]);        /* Modus    */
  653. X        modus ^= 1;            /* aendern    */
  654. X        sprintf(str,"modus %d",modus);
  655. X        schach(str,ptr);        /* setzen    */
  656. X        if(!(modus & 1))        /* aus ?    */
  657. X            ad_analyse("   a    b    c    d    e    f    g    h");
  658. X    }
  659. #endif
  660. X    else if(ch!=' ')            /* Space wird ignoriert    */
  661. X        beep();                /*** Fehler    ***/
  662. X
  663. X    return(1);
  664. }
  665. SHAR_EOF
  666. chmod 0644 ad/menu.c ||
  667. echo 'restore of ad/menu.c failed'
  668. Wc_c="`wc -c < 'ad/menu.c'`"
  669. test 3404 -eq "$Wc_c" ||
  670.     echo 'ad/menu.c: original size 3404, current size' "$Wc_c"
  671. rm -f _shar_wnt_.tmp
  672. fi
  673. # ============= ad/lock.c ==============
  674. if test -f 'ad/lock.c' -a X"$1" != X"-c"; then
  675.     echo 'x - skipping ad/lock.c (File already exists)'
  676.     rm -f _shar_wnt_.tmp
  677. else
  678. > _shar_wnt_.tmp
  679. echo 'x - extracting ad/lock.c (Text)'
  680. sed 's/^X//' << 'SHAR_EOF' > 'ad/lock.c' &&
  681. /****************************************************************/
  682. /*                                */
  683. /*    XChess V2.7 Adapter: Curses                */
  684. /*                                */
  685. /*    (c) 1991 by Marc Laukien                */
  686. /*                                */
  687. /*    Programmteil:    File Locking                */
  688. /*                                */
  689. /****************************************************************/
  690. X
  691. #include <curses.h>
  692. #include <stdio.h>
  693. #include <fcntl.h>
  694. #include "ad.h"
  695. X
  696. extern    unsigned    sleep();
  697. X
  698. /****************************************************************/
  699. /*    File locken                        */
  700. /****************************************************************/
  701. X
  702. void    ad_lock()
  703. X
  704. {
  705. X    int    fd;
  706. X    char    str[STRLEN];
  707. X
  708. X    if(!TURNGEG())                /* Computer = Gegner ?    */
  709. X        return;                /* Kein lock noetig    */
  710. X
  711. X    sprintf(str,"%s.lock",stdname);        /* Pfad aufbereiten    */
  712. X    
  713. X    while(1)
  714. X    {
  715. X        fd=open(str,O_WRONLY | O_CREAT | O_EXCL,0664);    /* Lock holen */
  716. X
  717. X        if(fd!=-1)                /* nicht locked ? */
  718. X            break;
  719. X
  720. X        sleep((unsigned)2);
  721. X    }
  722. X    
  723. X    close(fd);                    /* schliessen */
  724. X
  725. X    lock=1;
  726. }
  727. X
  728. /****************************************************************/
  729. /*    File unlocken                        */
  730. /****************************************************************/
  731. X
  732. void    ad_unlock()
  733. X
  734. {
  735. X    char str[STRLEN];    /* String fuer Pfad- und Dateinamen */
  736. X    
  737. X    if(!TURNGEG())        /* Computer = Gegner ?    */
  738. X        return;        /* Kein lock noetig    */
  739. X
  740. X    sprintf(str,"%s.lock",stdname);        /* Pfad aufbereiten    */
  741. X    if(unlink(str) == -1)            /* loeschen        */
  742. X        ad_error("");
  743. X
  744. X    lock=0;
  745. }
  746. X
  747. /****************************************************************/
  748. /*    Score locken                        */
  749. /****************************************************************/
  750. X
  751. void    ad_locksc()
  752. X
  753. {
  754. X    int    fd;
  755. X    static    char    *str="score.lock";
  756. X    
  757. X    while(1)
  758. X    {
  759. X        fd=open(str,O_WRONLY | O_CREAT | O_EXCL,0664);    /* Lock holen */
  760. X
  761. X        if(fd!=-1)                /* nicht locked ? */
  762. X            break;
  763. X
  764. X        sleep((unsigned)2);
  765. X    }
  766. X    
  767. X    close(fd);                    /* schliessen */
  768. X
  769. X    lock=1;
  770. }
  771. X
  772. /****************************************************************/
  773. /*    Score unlocken                        */
  774. /****************************************************************/
  775. X
  776. void    ad_unlocksc()
  777. X
  778. {
  779. X    if(unlink("score.lock") == -1)        /* loeschen        */
  780. X        ad_error("");
  781. X
  782. X    lock=0;
  783. }
  784. X
  785. SHAR_EOF
  786. chmod 0644 ad/lock.c ||
  787. echo 'restore of ad/lock.c failed'
  788. Wc_c="`wc -c < 'ad/lock.c'`"
  789. test 2071 -eq "$Wc_c" ||
  790.     echo 'ad/lock.c: original size 2071, current size' "$Wc_c"
  791. rm -f _shar_wnt_.tmp
  792. fi
  793. # ============= ad/admin.c ==============
  794. if test -f 'ad/admin.c' -a X"$1" != X"-c"; then
  795.     echo 'x - skipping ad/admin.c (File already exists)'
  796.     rm -f _shar_wnt_.tmp
  797. else
  798. > _shar_wnt_.tmp
  799. echo 'x - extracting ad/admin.c (Text)'
  800. sed 's/^X//' << 'SHAR_EOF' > 'ad/admin.c' &&
  801. /****************************************************************/
  802. /*                                */
  803. /*    XChess V2.7 Adapter: Curses                */
  804. /*                                */
  805. /*    (c) 1991 by Marc Laukien                */
  806. /*                                */
  807. /*    Programmteil:    Administrationsmenue            */
  808. /*                                */
  809. /****************************************************************/
  810. X
  811. #include <sys/types.h>
  812. #include <dirent.h>
  813. #include <string.h>
  814. #include <curses.h>
  815. #include <stdio.h>
  816. #include <ctype.h>
  817. X
  818. #include "ad.h"
  819. X
  820. /****************************************************************/
  821. /*    Menueeingabe                        */
  822. /****************************************************************/
  823. X
  824. void    ad_admin()
  825. X
  826. {
  827. X    char    ch;        /* Zeichen zum Einlesen        */
  828. X
  829. X    ad_admin_screen();    /* Bildaufbau            */
  830. X    ad_amenu();
  831. X    move(23,79);
  832. X    refresh();        /* ausgeben            */
  833. X
  834. X    while(1)
  835. X    {
  836. X        ad_read(0,&ch,1);        /* einlesen    */
  837. X        if(isupper(ch))            /* gross ?    */
  838. X            ch=tolower(ch);
  839. X
  840. X        ad_flush();    /* restliche Zeichen wegwerfen    */
  841. X
  842. X
  843. X        if(ch==amenu[0][0])        /*** Uebungsspiel    ***/
  844. X        {
  845. X            gegner[0]=0;        /* Computer ist Gegner    */
  846. X            ad_game();
  847. X
  848. X            ad_admin_screen();    /* Bildaufbau        */
  849. X            ad_amenu();
  850. X            move(23,79);
  851. X            refresh();        /* ausgeben        */
  852. X        }
  853. X        else if(ch==amenu[1][0])    /*** Trainingssp. zeigen ***/
  854. X        {
  855. X            ad_uliste();
  856. X
  857. X            ad_admin_screen();    /* Bildaufbau        */
  858. X            ad_amenu();
  859. X            move(23,79);
  860. X            refresh();        /* ausgeben        */
  861. X        }
  862. X        else if(ch==amenu[2][0])    /*** Trainingssp. loeschen ***/
  863. X        {
  864. X            char    *s;
  865. X            char    str[STRLEN*2];
  866. X
  867. X            s=ad_name('f');
  868. X
  869. X            sprintf(str,"%s.ch",s);
  870. X            if(unlink(str) == -1)    /* loeschen        */
  871. X                ad_error("");
  872. X
  873. X            ad_admin_screen();    /* Bildaufbau        */
  874. X            ad_amenu();
  875. X            move(23,79);
  876. X            refresh();        /* ausgeben        */
  877. X        }
  878. X        else if(ch==amenu[3][0])    /*** Weiss gegen Comp. ***/
  879. X        {
  880. X            strcpy(gegner,"~");
  881. X            wei=0;
  882. X            sch=1;
  883. X            ad_game();
  884. X
  885. X            ad_admin_screen();    /* Bildaufbau        */
  886. X            ad_amenu();
  887. X            move(23,79);
  888. X            refresh();        /* ausgeben        */
  889. X        }
  890. X        else if(ch==amenu[4][0])    /*** Schw. gegen Comp. ***/
  891. X        {
  892. X            strcpy(gegner,"~");
  893. X            wei=1;
  894. X            sch=0;
  895. X            ad_game();
  896. X
  897. X            ad_admin_screen();    /* Bildaufbau        */
  898. X            ad_amenu();
  899. X            move(23,79);
  900. X            refresh();        /* ausgeben        */
  901. X        }
  902. X        else if(ch==amenu[5][0])    /*** Weiss gegen Spieler ***/
  903. X        {
  904. X            strcpy(gegner,ad_name('g'));
  905. X            if(gegner[0]=='\0')    /* Kein Gegner ?    */
  906. X                continue;
  907. X            wei=0;
  908. X            sch=1;
  909. X            ad_game();
  910. X
  911. X            ad_admin_screen();    /* Bildaufbau        */
  912. X            ad_amenu();
  913. X            move(23,79);
  914. X            refresh();        /* ausgeben        */
  915. X        }
  916. X        else if(ch==amenu[6][0])    /*** Schw. gegen Spieler ***/
  917. X        {
  918. X            strcpy(gegner,ad_name('g'));
  919. X            if(gegner[0]=='\0')    /* Kein Gegner ?    */
  920. X                continue;
  921. X            wei=1;
  922. X            sch=0;
  923. X            ad_game();
  924. X
  925. X            ad_admin_screen();    /* Bildaufbau        */
  926. X            ad_amenu();
  927. X            move(23,79);
  928. X            refresh();        /* ausgeben        */
  929. X        }
  930. X        else if(ch==amenu[7][0])    /*** Turniersp. zeigen ***/
  931. X        {
  932. X            ad_tliste();
  933. X
  934. X            ad_admin_screen();    /* Bildaufbau        */
  935. X            ad_amenu();
  936. X            move(23,79);
  937. X            refresh();        /* ausgeben        */
  938. X        }
  939. X        else if(ch==amenu[8][0])    /*** Highscoreliste zeigen ***/
  940. X        {
  941. X            ad_showscore();
  942. X
  943. X            ad_admin_screen();    /* Bildaufbau        */
  944. X            ad_amenu();
  945. X            move(23,79);
  946. X            refresh();        /* ausgeben        */
  947. X        }
  948. X        else if(ch==amenu[9][0])    /*** Ende    ***/
  949. X        {
  950. X            if(ad_sure('s'))
  951. X                break;
  952. X        }
  953. X        else if(ch!=' ')        /* Space wird ign.    */
  954. X            beep();            /*** Fehler    ***/
  955. X    }
  956. }
  957. X
  958. /****************************************************************/
  959. /*    Turnierspielliste                    */
  960. /****************************************************************/
  961. X
  962. void    ad_tliste()
  963. X
  964. {
  965. X    char    c;
  966. X    int    i,j,y=2;
  967. X    DIR    *dir;        /* Directory - Pointer        */
  968. X    struct    dirent    *dp;    /* Pointer auf Eintrag        */
  969. X    char    str[STRLEN],str2[STRLEN];    /* String    */
  970. X    char    *s[3];
  971. X
  972. X    ad_admin_screen();    /* Bildaufbau            */
  973. X    attrset(A_UNDERLINE|A_BOLD);    /* Unterstreichen und Hell    */
  974. X    mvaddstr(y,1,tlist);
  975. X    attrset(0);            /* Attribute aus        */
  976. X
  977. X    if( (dir=opendir("save"))==(DIR *)0 )    /* oeffnen    */
  978. X    {
  979. X        ad_error("");        /* Fehler        */
  980. X        return;
  981. X    }
  982. X
  983. X    while( (dp=readdir(dir)) != (struct dirent *)0 )  /* Ende ?    */
  984. X    {
  985. X        strcpy(str,dp->d_name);    /* kopieren        */
  986. X
  987. X        i=0;
  988. X        j=0;
  989. X        s[j++]=str;
  990. X        while(str[i]!='\0')        /* String aufbereiten    */
  991. X        {
  992. X            if(str[i]=='.')
  993. X            {
  994. X                str[i++]='\0';    /* beenden    */
  995. X                s[j++]=str+i;
  996. X            }
  997. X
  998. X            if(j>=3)
  999. X                break;
  1000. X
  1001. X            i++;
  1002. X        }
  1003. X
  1004. X        if(j==3)            /* Spiel gefunden ?    */
  1005. X        {
  1006. X            if(y==21)        /* Bildschirmende ?    */
  1007. X            {
  1008. X                attrset(A_BOLD);/* Hell */
  1009. X                mvaddstr(++y,ADM_RAND,press_key);    /* TASTE */
  1010. X                move(23,79);
  1011. X                refresh();        /* ausgeben    */
  1012. X
  1013. X                ad_read(0,&c,1);    /* auf Taste warten */
  1014. X
  1015. X                ad_admin_screen();    /* Bildaufbau    */
  1016. X
  1017. X                y=2;
  1018. X                attrset(A_UNDERLINE|A_BOLD);
  1019. X                mvaddstr(y,1,tlist);
  1020. X                attrset(0);        /* Attribute aus */
  1021. X            }
  1022. X
  1023. X            if(!strcmp(ad_id(getlogin()),s[0]))
  1024. X                attrset(A_BOLD);    /* Hell        */
  1025. X            else
  1026. X                attrset(0);        /* Normal    */
  1027. X            mvaddstr(++y,ADM_RAND,ad_revid(s[0]));
  1028. X                            /* ausgeben    */
  1029. X
  1030. X            if(!strcmp(ad_id(getlogin()),s[1]))
  1031. X                attrset(A_BOLD);    /* Hell        */
  1032. X            else
  1033. X                attrset(0);        /* Normal    */
  1034. X            mvaddstr(y,ADM_RAND+15,ad_revid(s[1]));
  1035. X                            /* ausgeben    */
  1036. X
  1037. X            sprintf(str2,"loadinfo save/%s.%s",s[0],s[1]);
  1038. X                        /* Kommandostring     */
  1039. X            schach(str2,ptr);    /* Info anfordern     */
  1040. X
  1041. X            if(!strcmp(ad_id(getlogin()),ptr[0][0]=='w' ? s[0]:s[1]))
  1042. X                attrset(A_BOLD|A_BLINK);/* Hell & Blink    */
  1043. X            else
  1044. X                attrset(0);        /* Normal    */
  1045. X
  1046. X            mvaddstr(y,ADM_RAND+30,ptr[1]);    /* Zuege    */
  1047. X                            /* Farbe    */
  1048. X            mvaddstr(y,ADM_RAND+45,ptr[0][0]=='w' ? white:black);
  1049. X
  1050. X            refresh();
  1051. X        }
  1052. X    }
  1053. X
  1054. X    closedir(dir);
  1055. X    
  1056. X    attrset(A_BOLD);            /* Hell         */
  1057. X    mvaddstr(++y,ADM_RAND,press_key);    /* TASTE        */
  1058. X    move(23,79);
  1059. X    refresh();            /* ausgeben        */
  1060. X
  1061. X    ad_read(0,&c,1);        /* auf Taste warten    */
  1062. }
  1063. X
  1064. /****************************************************************/
  1065. /*    Trainingsspielliste                    */
  1066. /****************************************************************/
  1067. X
  1068. void    ad_uliste()
  1069. X
  1070. {
  1071. X    char    c;
  1072. X    int    i,j,y=2;
  1073. X    DIR    *dir;        /* Directory - Pointer        */
  1074. X    struct    dirent    *dp;    /* Pointer auf Eintrag        */
  1075. X    char    str[STRLEN],str2[STRLEN];    /* String    */
  1076. X    char    *s[3];
  1077. X
  1078. X    ad_admin_screen();    /* Bildaufbau            */
  1079. X    attrset(A_UNDERLINE|A_BOLD);    /* Unterstreichen und Hell    */
  1080. X    mvaddstr(y,1,ulist);
  1081. X    attrset(0);            /* Attribute aus        */
  1082. X
  1083. X    if( (dir=opendir("training"))==(DIR *)0 )    /* oeffnen    */
  1084. X    {
  1085. X        ad_error("");        /* Fehler        */
  1086. X        return;
  1087. X    }
  1088. X
  1089. X    while( (dp=readdir(dir)) != (struct dirent *)0 )  /* Ende ?    */
  1090. X    {
  1091. X        strcpy(str,dp->d_name);    /* kopieren        */
  1092. X
  1093. X        i=0;
  1094. X        j=0;
  1095. X        s[j++]=str;
  1096. X        while(str[i]!='\0')        /* String aufbereiten    */
  1097. X        {
  1098. X            if(str[i]=='.')
  1099. X            {
  1100. X                str[i++]='\0';    /* beenden    */
  1101. X                s[j++]=str+i;
  1102. X            }
  1103. X
  1104. X            if(j>=3)
  1105. X                break;
  1106. X
  1107. X            i++;
  1108. X        }
  1109. X
  1110. X        if(j==3)            /* Spiel gefunden ?    */
  1111. X        {
  1112. X            if(y==21)        /* Bildschirmende ?    */
  1113. X            {
  1114. X                attrset(A_BOLD);/* Hell */
  1115. X                mvaddstr(++y,ADM_RAND,press_key);    /* TASTE */
  1116. X                move(23,79);
  1117. X                refresh();        /* ausgeben    */
  1118. X
  1119. X                ad_read(0,&c,1);    /* auf Taste warten */
  1120. X
  1121. X                ad_admin_screen();    /* Bildaufbau    */
  1122. X
  1123. X                y=2;
  1124. X                attrset(A_UNDERLINE|A_BOLD);
  1125. X                mvaddstr(y,1,ulist);
  1126. X                attrset(0);        /* Attribute aus */
  1127. X            }
  1128. X
  1129. X            attrset(0);            /* Attribute aus */
  1130. X
  1131. X            if(strcmp(s[0],ad_id(getlogin())))
  1132. X                        /* Anderer Spieler ?     */
  1133. X                continue;
  1134. X
  1135. X            mvaddstr(++y,ADM_RAND,ad_revid(s[0]));
  1136. X            mvaddstr(y,ADM_RAND+15,s[1]);    /* ausgeben    */
  1137. X
  1138. X            sprintf(str2,"loadinfo training/%s.%s",s[0],s[1]);
  1139. X                        /* Kommandostring     */
  1140. X            schach(str2,ptr);    /* Info anfordern     */
  1141. X
  1142. X            mvaddstr(y,ADM_RAND+30,ptr[1]);    /* Zuege    */
  1143. X                            /* Farbe    */
  1144. X            mvaddstr(y,ADM_RAND+45,ptr[0][0]=='w' ? white:black);
  1145. X
  1146. X            refresh();
  1147. X        }
  1148. X    }
  1149. X
  1150. X    closedir(dir);
  1151. X    
  1152. X    attrset(A_BOLD);            /* Hell         */
  1153. X    mvaddstr(++y,ADM_RAND,press_key);    /* TASTE        */
  1154. X    move(23,79);
  1155. X    refresh();            /* ausgeben        */
  1156. X
  1157. X    ad_read(0,&c,1);        /* auf Taste warten    */
  1158. }
  1159. X
  1160. SHAR_EOF
  1161. chmod 0644 ad/admin.c ||
  1162. echo 'restore of ad/admin.c failed'
  1163. Wc_c="`wc -c < 'ad/admin.c'`"
  1164. test 7463 -eq "$Wc_c" ||
  1165.     echo 'ad/admin.c: original size 7463, current size' "$Wc_c"
  1166. rm -f _shar_wnt_.tmp
  1167. fi
  1168. # ============= ad/screen.c ==============
  1169. if test -f 'ad/screen.c' -a X"$1" != X"-c"; then
  1170.     echo 'x - skipping ad/screen.c (File already exists)'
  1171.     rm -f _shar_wnt_.tmp
  1172. else
  1173. > _shar_wnt_.tmp
  1174. echo 'x - extracting ad/screen.c (Text)'
  1175. sed 's/^X//' << 'SHAR_EOF' > 'ad/screen.c' &&
  1176. /****************************************************************/
  1177. /*                                */
  1178. /*    XChess V2.7 Adapter: Curses                */
  1179. /*                                */
  1180. /*    (c) 1991 by Marc Laukien                */
  1181. /*                                */
  1182. /*    Programmteil:    Bildschirmaufbau            */
  1183. /*                                */
  1184. /****************************************************************/
  1185. X
  1186. #include <curses.h>
  1187. #include <stdio.h>
  1188. #include <string.h>
  1189. #include <fcntl.h>
  1190. #include <ctype.h>
  1191. X
  1192. #include "ad.h"
  1193. #include "patchlevel.h"
  1194. X
  1195. /****************************************************************/
  1196. /*    Spielmenue-Screen                    */
  1197. /****************************************************************/
  1198. X
  1199. void    ad_game_screen()
  1200. X
  1201. {
  1202. X    int     x,y;
  1203. X    int    ch;
  1204. X
  1205. X    attrset(0);            /* Alle Attribute aus    */
  1206. X    erase();            /* loeschen        */
  1207. X
  1208. X    for(x=0;x<8*5;x++)        /* Alle Felder aufbauen    */
  1209. X    for(y=0;y<8*3;y++)
  1210. X    {                /* schwarz oder weiss ? */
  1211. X        if(y==0 || y==23)    /* oberste o. unterste    */
  1212. X        {            /* Reihe ?        */
  1213. X            if(!((x-2)%5))    /* Beschriftung ?    */
  1214. X                ch=(x+2)/5+(int)'a'|A_REVERSE;
  1215. X            else        /* Keine Beschriftung    */
  1216. X                ch=(int)' '|A_REVERSE;
  1217. X        }
  1218. X        else
  1219. X              ch=(int)' '|A_BOLD;    /* Normales Feld    */
  1220. X    
  1221. X        if(!((x/5)%2) ^ ((y/3)%2))    /* schw. Feld ?    */
  1222. X            ch |= A_REVERSE;
  1223. X
  1224. X        mvaddch(y,x+1,ch);    /* eintragen        */
  1225. X    }
  1226. X
  1227. X    for(y=0;y<8*3;y++)        /* Linie ziehen        */
  1228. X    {
  1229. X        if(!((y-1)%3))    /* Beschriftung ?    */
  1230. X            ch=7-(y+1)/3+(int)'1'|A_REVERSE;
  1231. X        else        /* Keine Beschriftung    */
  1232. X            ch=(int)' '|A_REVERSE;
  1233. X
  1234. X        mvaddch(y,8*5+1,ch);
  1235. X        mvaddch(y,0,ch);
  1236. X    }
  1237. X
  1238. X     attrset(A_REVERSE);    /* Invers ein        */
  1239. X      mvaddstr(0 ,2+5*8,"UNIX-Chess V2.7 (c) 1991 by M.Laukien ");
  1240. X    attrset(0);
  1241. X
  1242. X    attrset(A_REVERSE);    /* Invers ein        */
  1243. X    mvaddstr(18,2+5*8,"       ");
  1244. X    addstr(figlist);    /* Geschlagene Figuren    */
  1245. X    for(x=stdscr->_curx;x<79;x++)
  1246. X        addstr(" ");
  1247. X    attrset(0);
  1248. X
  1249. X    for(y=0;y<23;y++)    /* Rand            */
  1250. X        mvaddch(y,79,(int)' '|A_REVERSE);
  1251. X
  1252. X    for(x=2+5*8;x<79;x++)    /* Rand            */
  1253. X        mvaddch(23,x,(int)' '|A_REVERSE);
  1254. }
  1255. X
  1256. /****************************************************************/
  1257. /*    Spielmenue ausgeben                    */
  1258. /****************************************************************/
  1259. X
  1260. void    ad_menu()
  1261. X
  1262. {
  1263. X    int y=4;            /* Koordinaten    */
  1264. X    int x;
  1265. X    char str[STRLEN];        /* String    */
  1266. X    char c1=' ',c2=' ';
  1267. X
  1268. X    attrset(0);            /* Alle Attribute aus    */
  1269. X
  1270. X    if(TURNIER())            /* Turnierspiel    ?    */
  1271. X        c1='*';
  1272. X
  1273. X    sprintf(str,"%c%s%d",c1,menu[0]+1,level+1);/* LEVEL    */
  1274. X    mvaddstr(++y,MPOS-1,str);
  1275. X    for(x=stdscr->_curx;x<79;x++)    /* Rest der Zeile loeschen    */
  1276. X        mvaddch(y,x,(int)' ');
  1277. X    sprintf(str,"%c%s%s",c1,menu[1]+1,wei ?
  1278. X    (TURNGEG() ? gegner:comp) :getlogin());
  1279. X    mvaddstr(++y,MPOS-1,str);    /* WEISS        */
  1280. X    for(x=stdscr->_curx;x<79;x++)    /* Rest der Zeile loeschen    */
  1281. X        mvaddch(y,x,(int)' ');
  1282. X    sprintf(str,"%c%s%s",c1,menu[2]+1,sch ?
  1283. X    (TURNGEG() ? gegner:comp) :getlogin());
  1284. X    mvaddstr(++y,MPOS-1,str);    /* SCHWARZ        */
  1285. X    for(x=stdscr->_curx;x<79;x++)    /* Rest der Zeile loeschen    */
  1286. X        mvaddch(y,x,(int)' ');
  1287. X    if(TURNGEG())
  1288. X    sprintf(str,"%c%s%s",c1,menu[3]+1,modus & 128 ? ison:isoff);
  1289. X    else
  1290. X    sprintf(str,"%c%s%s%c",' ',menu[3]+1,modus & 128 ? ison:isoff,' ');
  1291. X    mvaddstr(++y,MPOS-1,str);    /* ANALYSE        */
  1292. X    for(x=stdscr->_curx;x<79;x++)    /* Rest der Zeile loeschen    */
  1293. X        mvaddch(y,x,(int)' ');
  1294. X    sprintf(str,"%c%s",c1,menu[4]+1);
  1295. X    mvaddstr(++y,MPOS-1,str);        /* SETUP        */
  1296. X    sprintf(str,"%c%s",c1,menu[5]+1);
  1297. X    mvaddstr(++y,MPOS-1,str);        /* ZURUECK        */
  1298. X    sprintf(str," %s ",menu[6]+1);
  1299. X    mvaddstr(++y,MPOS-1,str);        /* INFO            */
  1300. X    sprintf(str," %s ",menu[7]+1);
  1301. X    mvaddstr(++y,MPOS-1,str);        /* NEUSTART        */
  1302. X    sprintf(str," %s ",menu[8]+1);
  1303. X    mvaddstr(++y,MPOS-1,str);        /* ENDE            */
  1304. X    sprintf(str,"%c%s",c1,menu[9]+1);
  1305. X    mvaddstr(++y,MPOS-1,str);        /* BREAK        */
  1306. X
  1307. }
  1308. X
  1309. /****************************************************************/
  1310. /*    Adm.-Menue-Screen                    */
  1311. /****************************************************************/
  1312. X
  1313. void    ad_admin_screen()
  1314. X
  1315. {
  1316. X    int     x,y;
  1317. X    char    *header1=
  1318. "UNIX-Chess V2.7 PL%-2d      (c) 1991 by Marc Laukien     ";
  1319. X    char    *header2=
  1320. "Opening-Library           (c) 1990 by Christoph Thommes";
  1321. X    char    str[STRLEN];
  1322. X
  1323. X    sprintf(str,header1,PATCHLEVEL);/* aufbereiten        */
  1324. X
  1325. X    attrset(0);            /* Alle Attribute aus    */
  1326. X    erase();            /* loeschen        */
  1327. X
  1328. X    for(x=0;x<79;x++)        /* Bildschirmrand aufb.    */
  1329. X    {
  1330. X        mvaddch(0,x,(int)' '|A_REVERSE);
  1331. X        mvaddch(1,x,(int)' '|A_REVERSE);
  1332. X        mvaddch(23,x,(int)' '|A_REVERSE);
  1333. X    }
  1334. X
  1335. X    for(y=0;y<23;y++)        /* Bildschirmrand aufb.    */
  1336. X    {
  1337. X        mvaddch(y,0,(int)' '|A_REVERSE);
  1338. X        mvaddch(y,79,(int)' '|A_REVERSE);
  1339. X    }
  1340. X
  1341. X     attrset(A_REVERSE);        /* Invers ein        */
  1342. X      mvaddstr(0 ,ADM_RAND,str);
  1343. X      mvaddstr(1 ,ADM_RAND,header2);
  1344. }
  1345. X
  1346. /****************************************************************/
  1347. /*    Adm.-Menue ausgeben                    */
  1348. /****************************************************************/
  1349. X
  1350. void    ad_amenu()
  1351. X
  1352. {
  1353. X    int     x,y=3;            /* Koordinaten        */
  1354. X    char    str[STRLEN];
  1355. X
  1356. X    attrset(A_BOLD);        /* Hell ein        */
  1357. X
  1358. X    sprintf(str,"%s",amenu[0]+1);
  1359. X    mvaddstr(y,ADM_RAND,str);        /* TRAINING        */
  1360. X    sprintf(str,"%s",amenu[1]+1);
  1361. X    mvaddstr(++y,ADM_RAND,str);        /* ZEIGE TRAININGSSP.    */
  1362. X    sprintf(str,"%s",amenu[2]+1);
  1363. X    mvaddstr(++y,ADM_RAND,str);        /* LOESCHE TRAININGSSP.    */
  1364. X
  1365. X    attrset(A_NORMAL);        /* Hell aus        */
  1366. X
  1367. X    y+=2;
  1368. X    for(x=1;x<79;x++)            /* Trennstrich aufb.    */
  1369. X        mvaddch(y,x,(int)'-'|A_NORMAL);
  1370. X
  1371. X    attrset(A_BOLD);        /* Hell ein        */
  1372. X
  1373. X    sprintf(str,"%s",amenu[3]+1);
  1374. X    mvaddstr(y+=2,ADM_RAND,str);        /* TURNIER WEISS COMP    */
  1375. X    sprintf(str,"%s",amenu[4]+1);
  1376. X    mvaddstr(++y,ADM_RAND,str);        /* TURNIER SCHWARZ COMP    */
  1377. X    sprintf(str,"%s",amenu[5]+1);
  1378. X    mvaddstr(y+=2,ADM_RAND,str);        /* TURNIER WEISS    */
  1379. X    sprintf(str,"%s",amenu[6]+1);
  1380. X    mvaddstr(++y,ADM_RAND,str);        /* TURNIER SCHWARZ    */
  1381. X    sprintf(str,"%s",amenu[7]+1);
  1382. X    mvaddstr(y+=2,ADM_RAND,str);        /* ZEIGE TURNIERSP.    */
  1383. X    sprintf(str,"%s",amenu[8]+1);
  1384. X    mvaddstr(++y,ADM_RAND,str);        /* ZEIGE HIGHSCORE    */
  1385. X
  1386. X    attrset(A_NORMAL);        /* Hell aus        */
  1387. X
  1388. X    y+=2;
  1389. X    for(x=1;x<79;x++)            /* Trennstrich aufb.    */
  1390. X        mvaddch(y,x,(int)'-'|A_NORMAL);
  1391. X
  1392. X    attrset(A_BOLD);        /* Hell ein        */
  1393. X
  1394. X    sprintf(str,"%s",amenu[9]+1);
  1395. X    mvaddstr(y+=2,ADM_RAND,str);        /* ENDE            */
  1396. }
  1397. X
  1398. X
  1399. SHAR_EOF
  1400. chmod 0644 ad/screen.c ||
  1401. echo 'restore of ad/screen.c failed'
  1402. Wc_c="`wc -c < 'ad/screen.c'`"
  1403. test 5856 -eq "$Wc_c" ||
  1404.     echo 'ad/screen.c: original size 5856, current size' "$Wc_c"
  1405. rm -f _shar_wnt_.tmp
  1406. fi
  1407. # ============= ad/id.c ==============
  1408. if test -f 'ad/id.c' -a X"$1" != X"-c"; then
  1409.     echo 'x - skipping ad/id.c (File already exists)'
  1410.     rm -f _shar_wnt_.tmp
  1411. else
  1412. > _shar_wnt_.tmp
  1413. echo 'x - extracting ad/id.c (Text)'
  1414. sed 's/^X//' << 'SHAR_EOF' > 'ad/id.c' &&
  1415. /****************************************************************/
  1416. /*                                */
  1417. /*    XChess V2.7 Adapter: Curses                */
  1418. /*                                */
  1419. /*    (c) 1991 by Marc Laukien                */
  1420. /*                                */
  1421. /*    Programmteil:    Spieler-ID liefern            */
  1422. /*                                */
  1423. /****************************************************************/
  1424. X
  1425. #include <curses.h>
  1426. #include <pwd.h>
  1427. #include "ad.h"
  1428. X
  1429. /****************************************************************/
  1430. /*    String mit ID zu Username liefern            */
  1431. /****************************************************************/
  1432. /*    Return:    String mit ID                    */
  1433. /****************************************************************/
  1434. X
  1435. char    *ad_id(name)
  1436. X
  1437. char    *name;
  1438. {
  1439. X    static    char    id[STRLEN];
  1440. X    struct    passwd    *pwd;
  1441. X
  1442. X    if(name[0]=='~' || strcmp(name,comp)==0)    /* Rechner ?    */
  1443. X        return("~");
  1444. X
  1445. X    pwd=getpwnam(name);        /* Passwordeintrag holen    */
  1446. X
  1447. X    if(pwd!=(struct passwd *)0)    /* Kein 0-Pointer ?        */
  1448. X        sprintf(id,"%d",pwd->pw_uid);
  1449. X    else
  1450. X        strcpy(id,"?");
  1451. X
  1452. X    return(id);
  1453. }
  1454. X
  1455. /****************************************************************/
  1456. /*    String mit Username zu ID liefern            */
  1457. /****************************************************************/
  1458. /*    Return:    String mit Username                */
  1459. /****************************************************************/
  1460. X
  1461. char    *ad_revid(id)
  1462. X
  1463. char    *id;
  1464. {
  1465. X    static    char    name[STRLEN];
  1466. X    struct    passwd    *pwd;
  1467. X
  1468. X    if(id[0]=='~')            /* Rechner ?            */
  1469. X        return(comp);
  1470. X
  1471. X    pwd=getpwuid(atoi(id));        /* Passwordeintrag holen    */
  1472. X
  1473. X    if(pwd!=(struct passwd *)0)    /* Kein 0-Pointer ?        */
  1474. X        sprintf(name,"%s",pwd->pw_name);
  1475. X    else
  1476. X        sprintf(name,"%s",id);
  1477. X
  1478. X    return(name);
  1479. }
  1480. X
  1481. X
  1482. SHAR_EOF
  1483. chmod 0644 ad/id.c ||
  1484. echo 'restore of ad/id.c failed'
  1485. Wc_c="`wc -c < 'ad/id.c'`"
  1486. test 1569 -eq "$Wc_c" ||
  1487.     echo 'ad/id.c: original size 1569, current size' "$Wc_c"
  1488. rm -f _shar_wnt_.tmp
  1489. fi
  1490. # ============= ad/score.c ==============
  1491. if test -f 'ad/score.c' -a X"$1" != X"-c"; then
  1492.     echo 'x - skipping ad/score.c (File already exists)'
  1493.     rm -f _shar_wnt_.tmp
  1494. else
  1495. > _shar_wnt_.tmp
  1496. echo 'x - extracting ad/score.c (Text)'
  1497. sed 's/^X//' << 'SHAR_EOF' > 'ad/score.c' &&
  1498. /****************************************************************/
  1499. /*                                */
  1500. /*    XChess V2.7 Adapter: Curses                */
  1501. /*                                */
  1502. /*    (c) 1991 by Marc Laukien                */
  1503. /*                                */
  1504. /*    Programmteil:    Highscore                */
  1505. /*                                */
  1506. /****************************************************************/
  1507. X
  1508. #include <curses.h>
  1509. #include <stdio.h>
  1510. #include <string.h>
  1511. #include <memory.h>
  1512. #include "ad.h"
  1513. X
  1514. /****************************************************************/
  1515. /*    Highscoreeintrag anhaengen                */
  1516. /****************************************************************/
  1517. X
  1518. void    ad_addscore(stat)
  1519. X
  1520. char    stat;    /* Status    */
  1521. {
  1522. X    FILE     *fp;
  1523. X    long    ti;
  1524. X
  1525. X    ad_locksc();    /* locken    */
  1526. X
  1527. X    if((fp=fopen("score.list","a"))==(FILE *)0)    /* oeffnen    */
  1528. X    {
  1529. X        ad_error("");
  1530. X        return;
  1531. X    }
  1532. X
  1533. X    ti=time((long *)0);
  1534. X
  1535. X    fprintf(fp,"%c    %s    ",
  1536. X    stat,
  1537. X    wei==0 ? ad_id(getlogin()):ad_id(gegner));
  1538. X
  1539. X    fprintf(fp,"%s    ",
  1540. X    sch==0 ? ad_id(getlogin()):ad_id(gegner));
  1541. X
  1542. X    fprintf(fp,"# %s vs. %s    %s",
  1543. X    wei==0 ? getlogin(): gegner[0]=='~' ? comp:gegner,
  1544. X    sch==0 ? getlogin(): gegner[0]=='~' ? comp:gegner,
  1545. X    ctime(&ti));    /* Datum    */
  1546. X
  1547. X    fclose(fp);        /* schliessen    */
  1548. X
  1549. X    ad_unlocksc();        /* unlocken    */
  1550. }
  1551. X
  1552. /****************************************************************/
  1553. /*    Highscoreeintrag anhaengen fuer expire            */
  1554. /****************************************************************/
  1555. X
  1556. void    ad_addscore_expire(stat,white,black)
  1557. X
  1558. char    stat;        /* Status    */
  1559. char    *white,*black;    /* Spieler    */
  1560. {
  1561. X    FILE     *fp;
  1562. X    long    ti;
  1563. X
  1564. X    ad_locksc();    /* locken    */
  1565. X
  1566. X    if((fp=fopen("score.list","a"))==(FILE *)0)    /* oeffnen    */
  1567. X    {
  1568. X        ad_error("");
  1569. X        return;
  1570. X    }
  1571. X
  1572. X    ti=time((long *)0);
  1573. X
  1574. X    fprintf(fp,"%c    %s    ",stat,ad_id(white));
  1575. X    fprintf(fp,"%s    ",ad_id(black));
  1576. X
  1577. X    fprintf(fp,"# (exp) %s vs. %s    %s",white,black,ctime(&ti));
  1578. X                /* Kommentar */
  1579. X
  1580. X    fclose(fp);        /* schliessen    */
  1581. X
  1582. X    ad_unlocksc();        /* unlocken    */
  1583. }
  1584. X
  1585. /****************************************************************/
  1586. /*    Highscore ausgeben                    */
  1587. /****************************************************************/
  1588. X
  1589. void    ad_showscore()
  1590. X
  1591. {
  1592. X    FILE    *fp;
  1593. X    char    c,s1[STRLEN],s2[STRLEN],str[STRLEN];
  1594. X    int    i,j,y=2,nr=0;
  1595. X    char    *my_id;
  1596. X
  1597. X    struct
  1598. X    {
  1599. X        char    id[7];    /* User-ID            */
  1600. X        double    score;    /* Punkte            */
  1601. X        int    nr;    /* Anzahl der Spiele        */
  1602. X        int    comp;    /* Davon gegen den Computer    */
  1603. X    } score[1000],copy;
  1604. X
  1605. X    if((fp=fopen("score.list","r"))==(FILE *)0)    /* oeffnen    */
  1606. X    {
  1607. X        ad_error("");
  1608. X        return;
  1609. X    }
  1610. X
  1611. X    while(!feof(fp) && nr<1000)    /* Dateiende ?    */
  1612. X    {
  1613. X        if(fgets(str,STRLEN,fp)==(char *)0)    /* einlesen     */
  1614. X            continue;
  1615. X        sscanf(str,"%c %s %s",&c,s1,s2);
  1616. X
  1617. X        for(i=0;i<nr;i++)    /* Spieler 1 suchen        */
  1618. X            if(!strcmp(score[i].id,s1))
  1619. X                break;
  1620. X
  1621. X        if(i==nr)    /* Neueintrag ?        */
  1622. X        {
  1623. X            strcpy(score[i].id,s1);    /* Name kopieren    */
  1624. X            score[i].score=1000.0;    /* Punkte        */
  1625. X            score[i].nr=0;
  1626. X            score[i].comp=0;
  1627. X            nr++;
  1628. X        }
  1629. X
  1630. X        for(j=0;j<nr;j++)    /* Spieler 2 suchen        */
  1631. X            if(!strcmp(score[j].id,s2))
  1632. X                break;
  1633. X
  1634. X        if(j==nr)    /* Neueintrag ?        */
  1635. X        {
  1636. X            strcpy(score[j].id,s2);    /* Name kopieren    */
  1637. X            score[j].score=1000.0;    /* Punkte        */
  1638. X            score[j].nr=0;
  1639. X            score[j].comp=0;
  1640. X            nr++;
  1641. X        }
  1642. X        
  1643. X        score[i].nr++;    /* Ein Spiel mehr    */
  1644. X        score[j].nr++;
  1645. X
  1646. X        if(s1[0] == '~')    /* Computer ?    */
  1647. X            score[j].comp++;
  1648. X        if(s2[0] == '~')
  1649. X            score[i].comp++;
  1650. X
  1651. X        switch(c)    /* Score veraendern    */
  1652. X        {
  1653. X        case 'w':    /* Gewinn Weiss    */
  1654. X        case 'W':
  1655. X            score[i].score += score[j].score/4;
  1656. X            score[j].score -= score[j].score/4;
  1657. X            break;
  1658. X
  1659. X        case 'b':    /* Gewinn Schwarz    */
  1660. X        case 'B':
  1661. X            score[j].score += score[i].score/4;
  1662. X            score[i].score -= score[i].score/4;
  1663. X            break;
  1664. X        }    
  1665. X    }
  1666. X
  1667. X    fclose(fp);
  1668. X
  1669. X    ad_admin_screen();    /* Bildaufbau            */
  1670. X    attrset(A_UNDERLINE|A_BOLD);    /* Unterstreichen und Hell    */
  1671. X    mvaddstr(y,1,scorelist);
  1672. X    attrset(0);            /* Attribute aus        */
  1673. X
  1674. X    for(i=0  ;i<nr-1;i++)            /* sortieren        */
  1675. X    for(j=i+1;j<nr  ;j++)
  1676. X        if(score[i].score < score[j].score)
  1677. X        {
  1678. X        memcpy((char *)©,(char *)&score[i],sizeof(copy));
  1679. X        memcpy((char *)&score[i],(char *)&score[j],sizeof(copy));
  1680. X        memcpy((char *)&score[j],(char *)©,sizeof(copy));
  1681. X        }
  1682. X
  1683. X    my_id=ad_id(getlogin());    /* ID des Benutzers    */
  1684. X
  1685. X    for(i=0;i<nr;i++)
  1686. X    {
  1687. X        if(y==21)        /* Bildschirmende ?    */
  1688. X        {
  1689. X            attrset(A_BOLD);/* Hell */
  1690. X            mvaddstr(++y,ADM_RAND,press_key);    /* TASTE */
  1691. X            move(23,79);
  1692. X            refresh();        /* ausgeben    */
  1693. X
  1694. X            ad_read(0,&c,1);    /* auf Taste warten */
  1695. X
  1696. X            ad_admin_screen();    /* Bildaufbau    */
  1697. X
  1698. X            y=2;
  1699. X            attrset(A_UNDERLINE|A_BOLD);
  1700. X            mvaddstr(y,1,scorelist);
  1701. X            attrset(0);        /* Attribute aus */
  1702. X        }
  1703. X
  1704. X        sprintf(s1,"%6.0lf",score[i].score);
  1705. X        sprintf(s2,"%d",score[i].nr);
  1706. X        sprintf(str,"%d",score[i].comp);
  1707. X
  1708. X        if(!strcmp(my_id,score[i].id))
  1709. X            attrset(A_BLINK);    /* Blinken */
  1710. X        else if(i<3)    /* Top 3 ?    */
  1711. X            attrset(A_BOLD);    /* Hell */
  1712. X        else
  1713. X            attrset(0);        /* Normal */
  1714. X
  1715. X        mvaddstr(++y,ADM_RAND,ad_revid(score[i].id));
  1716. X        mvaddstr(y,ADM_RAND+15,s2);
  1717. X        mvaddstr(y,ADM_RAND+30,str);
  1718. X        mvaddstr(y,ADM_RAND+45,s1);    /* ausgeben    */
  1719. X    }
  1720. X
  1721. X    fclose(fp);
  1722. X    
  1723. X    attrset(A_BOLD);            /* Hell         */
  1724. X    mvaddstr(++y,ADM_RAND,press_key);    /* TASTE        */
  1725. X    move(23,79);
  1726. X    refresh();            /* ausgeben        */
  1727. X
  1728. X    ad_read(0,&c,1);        /* auf Taste warten    */
  1729. }
  1730. X
  1731. SHAR_EOF
  1732. chmod 0644 ad/score.c ||
  1733. echo 'restore of ad/score.c failed'
  1734. Wc_c="`wc -c < 'ad/score.c'`"
  1735. test 5003 -eq "$Wc_c" ||
  1736.     echo 'ad/score.c: original size 5003, current size' "$Wc_c"
  1737. rm -f _shar_wnt_.tmp
  1738. fi
  1739. # ============= ad/training.c ==============
  1740. if test -f 'ad/training.c' -a X"$1" != X"-c"; then
  1741.     echo 'x - skipping ad/training.c (File already exists)'
  1742.     rm -f _shar_wnt_.tmp
  1743. else
  1744. > _shar_wnt_.tmp
  1745. echo 'x - extracting ad/training.c (Text)'
  1746. sed 's/^X//' << 'SHAR_EOF' > 'ad/training.c' &&
  1747. /****************************************************************/
  1748. /*                                */
  1749. /*    XChess V2.7 Adapter: Curses                */
  1750. /*                                */
  1751. /*    (c) 1991 by Marc Laukien                */
  1752. /*                                */
  1753. /*    Programmteil:    Uebungsspiel                */
  1754. /*                                */
  1755. /****************************************************************/
  1756. X
  1757. #include <curses.h>
  1758. #include <stdio.h>
  1759. #include <string.h>
  1760. #include <fcntl.h>
  1761. #include <ctype.h>
  1762. #include <sys/types.h>
  1763. #include "ad.h"
  1764. X
  1765. /****************************************************************/
  1766. /*    Uebungsspiel                        */
  1767. /****************************************************************/
  1768. X
  1769. void    ad_tr_game()
  1770. X
  1771. {
  1772. X    char     ch='\0';    /* Eingabe        */
  1773. X    char    s[STRLEN];    /* String        */
  1774. X    int    ret;        /* Return von domenu    */
  1775. X
  1776. X    sprintf(stdname,"training/%s.std",ad_id(getlogin()));
  1777. X
  1778. X    ad_lock();
  1779. X    sprintf(s,"load %s",stdname);
  1780. X    schach(s,ptr);        /* Laden        */
  1781. X    ad_unlock();
  1782. X
  1783. X    schach("info",ptr);    /* Info holen        */
  1784. X    modus = atoi(ptr[9]);    /* merken        */
  1785. X    farbe = ptr[0][0];
  1786. X    level = atoi(ptr[6]);
  1787. X
  1788. X    if(farbe=='w')    /* Farbe einst.        */
  1789. X    {
  1790. X        wei=0;
  1791. X        sch=1;
  1792. X    }
  1793. X    else
  1794. X    {
  1795. X        sch=0;
  1796. X        wei=1;
  1797. X    }
  1798. X
  1799. X    ad_menu();        /* Menue ausgeben    */
  1800. X    ad_brett();        /* Brett aufbauen    */
  1801. X    refresh();        /* ausgeben        */
  1802. X
  1803. X    while(1)
  1804. X    {
  1805. X        /*--- Computer -----------------------------------------*/
  1806. X        if(!ende && ((farbe=='w' && wei) || (farbe=='s' && sch)))
  1807. X        {    /* Computerzug    */
  1808. X            int    x;
  1809. X
  1810. X            mvaddstr(2,MPOS,thinking);/* Status ausgeben    */
  1811. X            move(23,79);
  1812. X            refresh();
  1813. X
  1814. X            schach("comp",ptr);    /* Zug holen    */
  1815. X
  1816. X            ad_brett();        /* Brett aufbauen    */
  1817. X
  1818. X            schach("info",ptr);    /* Info holen    */
  1819. X            farbe=ptr[0][0];    /* Farbe am Zug    */
  1820. X
  1821. X            move(2,MPOS);        /* Meldung loeschen    */
  1822. X            for(x=stdscr->_curx;x<79;x++)    /* loeschen    */
  1823. X                mvaddch(stdscr->_cury,x,(int)' ');
  1824. X        }
  1825. X        else
  1826. X        /*--- Spieler ------------------------------------------*/
  1827. X        {
  1828. X            if(ch=='\0')
  1829. X                ad_read(0,&ch,1);/* einlesen    */
  1830. X
  1831. X            if(isupper(ch))        /* gross ?    */
  1832. X                ch=tolower(ch);
  1833. X
  1834. X            ad_flush();    /* restliche Zeichen wegwerfen    */
  1835. X
  1836. X            ret=ad_domenu(ch);    /* auswerten        */
  1837. X            
  1838. X            if(ret==0)        /* Ende ?        */
  1839. X            {
  1840. X                ad_lock();
  1841. X                sprintf(s,"save %s",stdname);
  1842. X                schach(s,ptr);    /* Speichern        */
  1843. X                ad_unlock();
  1844. X                break;
  1845. X            }
  1846. X            else if(ret==2)        /* Neustart ?        */
  1847. X            {
  1848. X                if(ad_sure('s'))
  1849. X                    ad_new();
  1850. X            }
  1851. X        }
  1852. X
  1853. X        ch='\0';
  1854. X
  1855. X        /*--- Abbruch der Demo ---------------------------------*/
  1856. X
  1857. X        if(wei && sch)            /* Demo ?         */
  1858. X        {
  1859. X            int     flags;        /* Flags fuer ad_read()    */
  1860. X            int    ret;
  1861. X
  1862. X            flags=fcntl(0,F_GETFL,0);    /* flags retten */
  1863. X
  1864. X            fcntl(0,F_SETFL,flags | O_NDELAY); /* block aus    */
  1865. X            ret=ad_read(0,&ch,1);           /* einlesen    */
  1866. X            fcntl(0,F_SETFL,flags & ~O_NDELAY);/* block ein */
  1867. X
  1868. X            ad_flush();    /* restliche Zeichen wegwerfen    */
  1869. X            if(ret>0 || ende)        /* stopp ?     */
  1870. X            {
  1871. X                if(farbe=='w')
  1872. X                    wei=0;
  1873. X                else
  1874. X                    sch=0;
  1875. X
  1876. X                ad_menu();
  1877. X            }
  1878. X            else
  1879. X                ch='\0';
  1880. X        }
  1881. X
  1882. X        /*--- alles ausgeben ---------------------------*/
  1883. X
  1884. X        move(23,79);        /* Cursor weg        */
  1885. X        refresh();        /* ausgeben        */
  1886. X    }
  1887. X
  1888. X    stdname[0]='\0';    /* Kein Standardname    */
  1889. }
  1890. SHAR_EOF
  1891. chmod 0644 ad/training.c ||
  1892. echo 'restore of ad/training.c failed'
  1893. Wc_c="`wc -c < 'ad/training.c'`"
  1894. test 2942 -eq "$Wc_c" ||
  1895.     echo 'ad/training.c: original size 2942, current size' "$Wc_c"
  1896. rm -f _shar_wnt_.tmp
  1897. fi
  1898. # ============= ad/tour_user.c ==============
  1899. if test -f 'ad/tour_user.c' -a X"$1" != X"-c"; then
  1900.     echo 'x - skipping ad/tour_user.c (File already exists)'
  1901.     rm -f _shar_wnt_.tmp
  1902. else
  1903. > _shar_wnt_.tmp
  1904. echo 'x - extracting ad/tour_user.c (Text)'
  1905. sed 's/^X//' << 'SHAR_EOF' > 'ad/tour_user.c' &&
  1906. /****************************************************************/
  1907. /*                                */
  1908. /*    XChess V2.7 Adapter: Curses                */
  1909. /*                                */
  1910. /*    (c) 1991 by Marc Laukien                */
  1911. /*                                */
  1912. /*    Programmteil:    Spielmenue                */
  1913. /*                                */
  1914. /****************************************************************/
  1915. X
  1916. #include <curses.h>
  1917. #include <stdio.h>
  1918. #include <string.h>
  1919. #include <fcntl.h>
  1920. #include <ctype.h>
  1921. #include <time.h>
  1922. #include <sys/types.h>
  1923. X
  1924. #include "ad.h"
  1925. X
  1926. /****************************************************************/
  1927. /*    Turnierspiel gegen ext. Gegner                */
  1928. /****************************************************************/
  1929. X
  1930. void    ad_tu_game()
  1931. X
  1932. {
  1933. X    char     ch='\0';    /* Eingabe        */
  1934. X    char    s[STRLEN];    /* String        */
  1935. X    int    ret;        /* Return von domenu    */
  1936. X
  1937. X    /* Pfad zum Speichern    */
  1938. X    sprintf(stdname,"save/%s",wei==0 ? ad_id(getlogin()):
  1939. X    ad_id(gegner));
  1940. X    sprintf(stdname+strlen(stdname),".%s", sch==0 ?
  1941. X    ad_id(getlogin()):ad_id(gegner));
  1942. X
  1943. X    ad_lock();
  1944. X    sprintf(s,"load %s",stdname);
  1945. X    schach(s,ptr);        /* Laden        */
  1946. X
  1947. X    if(ptr[0][0]=='?')    /* existiert noch nicht ?    */
  1948. X    {
  1949. X        sprintf(s,"save %s",stdname);
  1950. X        schach(s,ptr);        /* Laden        */
  1951. X    }
  1952. X
  1953. X    ad_unlock();
  1954. X
  1955. X    schach("info",ptr);    /* Info holen        */
  1956. X    modus = atoi(ptr[9]);    /* merken        */
  1957. X    farbe = ptr[0][0];
  1958. X    level = atoi(ptr[6]);
  1959. X
  1960. X    ad_menu();        /* Menue ausgeben    */
  1961. X    ad_brett();        /* Brett aufbauen    */
  1962. X    refresh();        /* ausgeben        */
  1963. X
  1964. X    while(1)
  1965. X    {
  1966. X        /*--- Spielendeueberpruefung ---------------------------*/
  1967. X        if(ende)        /* Spiel zu Ende ?    */
  1968. X        {
  1969. X            switch(ende)
  1970. X            {
  1971. X            case W_AUFG:    /* Weiss gibt auf    */
  1972. X            case W_MATT:     /* Weiss ist matt    */
  1973. X                mvaddstr(2,MPOS,press_key);
  1974. X                move(23,79);
  1975. X                refresh();
  1976. X                ad_read(0,&ch,1);/* einlesen    */
  1977. X
  1978. X                if((farbe=='w' && W_IS_USER())
  1979. X                || (farbe=='s' && B_IS_USER()))
  1980. X                {    /* wer am Zug ist, traegt ein    */
  1981. X                    ad_remove();
  1982. X                    ad_addscore('B');/* Score     */
  1983. X                }
  1984. X
  1985. X                break;
  1986. X
  1987. X            case S_AUFG:    /* Schwarz gibt auf    */
  1988. X            case S_MATT:     /* Schwarz ist matt    */
  1989. X                mvaddstr(2,MPOS,press_key);
  1990. X                move(23,79);
  1991. X                refresh();
  1992. X                ad_read(0,&ch,1);/* einlesen    */
  1993. X
  1994. X                if((farbe=='w' && W_IS_USER())
  1995. X                || (farbe=='s' && B_IS_USER()))
  1996. X                {    /* wer am Zug ist, traegt ein    */
  1997. X                    ad_remove();
  1998. X                    ad_addscore('W');/* Score     */
  1999. X                }
  2000. X
  2001. X                break;
  2002. X
  2003. X            case PATT:    /* Unentschieden    */
  2004. X                mvaddstr(2,MPOS,press_key);
  2005. X                move(23,79);
  2006. X                refresh();
  2007. X                ad_read(0,&ch,1);/* einlesen    */
  2008. X
  2009. X                if((farbe=='w' && W_IS_USER())
  2010. X                || (farbe=='s' && B_IS_USER()))
  2011. X                {    /* wer am Zug ist, traegt ein    */
  2012. X                    ad_remove();
  2013. X                    ad_addscore('-');/* Score     */
  2014. X                }
  2015. X
  2016. X                break;
  2017. X            }
  2018. X
  2019. X            break;        /* Ende         */
  2020. X        }
  2021. X        /*--- Externer Gegner -----------------------------------*/
  2022. X        else if((farbe=='w' && W_IS_OPP())
  2023. X             || (farbe=='s' && B_IS_OPP()))
  2024. X        {
  2025. X            int     flags;    /* Flags fuer ad_read() */
  2026. X            int    ret;
  2027. X            int     x;
  2028. X            char    str[STRLEN];
  2029. X
  2030. X            sprintf(str,"%s %s",gegner,is_thinking);
  2031. X            mvaddstr(2,MPOS,str);    /* Status ausgeben*/
  2032. X            move(23,79);
  2033. X            refresh();
  2034. X            ad_extzug();
  2035. X
  2036. X            move(2,MPOS);    /* Meldung loeschen    */
  2037. X            for(x=stdscr->_curx;x<79;x++)    /* loeschen*/
  2038. X                mvaddch(stdscr->_cury,x,(int)' ');
  2039. X
  2040. X            move(23,79);
  2041. X            refresh();
  2042. X
  2043. X            /*--- Benutzereingabe 1 ----------------*/
  2044. X
  2045. X            flags=fcntl(0,F_GETFL,0);/* flags retten */
  2046. X
  2047. X            fcntl(0,F_SETFL,flags | O_NDELAY);
  2048. X            ret=ad_read(0,&ch,1);     /* einlesen    */
  2049. X            fcntl(0,F_SETFL,flags & ~O_NDELAY);
  2050. X
  2051. X            if(ret==0)
  2052. X                ch=' ';
  2053. X        }
  2054. X
  2055. X        /*--- Benutzereingabe 2 ------------------------*/
  2056. X        {
  2057. X            if(ch=='\0')
  2058. X                ad_read(0,&ch,1);/* einlesen    */
  2059. X
  2060. X            if(isupper(ch))        /* gross ?    */
  2061. X                ch=tolower(ch);
  2062. X
  2063. X            ad_flush();    /* restliche Zeichen wegwerfen    */
  2064. X
  2065. X            ret=ad_domenu(ch);    /* auswerten        */
  2066. X
  2067. X            if(ret==0)        /* Ende ?        */
  2068. X                break;
  2069. X            else if(ret==2)
  2070. X            {
  2071. X                if((farbe=='w' && wei) || (farbe=='s' && sch))
  2072. X                    ad_error(not_allowed);
  2073. X                else if(ad_sure('a'))
  2074. X                {
  2075. X                    move(3,MPOS);
  2076. X
  2077. X                    addstr(wei==0 ? w_up:b_up);
  2078. X                    ende = wei==0 ? W_AUFG:S_AUFG;
  2079. X                }
  2080. X            }
  2081. X        }
  2082. X
  2083. X        ch='\0';
  2084. X
  2085. X        /*--- alles ausgeben ---------------------------*/
  2086. X
  2087. X        move(23,79);        /* Cursor weg        */
  2088. X        refresh();        /* ausgeben        */
  2089. X    }
  2090. X
  2091. X    stdname[0]='\0';    /* Kein Standardname    */
  2092. }
  2093. SHAR_EOF
  2094. chmod 0644 ad/tour_user.c ||
  2095. echo 'restore of ad/tour_user.c failed'
  2096. Wc_c="`wc -c < 'ad/tour_user.c'`"
  2097. test 4036 -eq "$Wc_c" ||
  2098.     echo 'ad/tour_user.c: original size 4036, current size' "$Wc_c"
  2099. rm -f _shar_wnt_.tmp
  2100. fi
  2101. # ============= ad/tour_comp.c ==============
  2102. if test -f 'ad/tour_comp.c' -a X"$1" != X"-c"; then
  2103.     echo 'x - skipping ad/tour_comp.c (File already exists)'
  2104.     rm -f _shar_wnt_.tmp
  2105. else
  2106. > _shar_wnt_.tmp
  2107. echo 'x - extracting ad/tour_comp.c (Text)'
  2108. sed 's/^X//' << 'SHAR_EOF' > 'ad/tour_comp.c' &&
  2109. /****************************************************************/
  2110. /*                                */
  2111. /*    XChess V2.7 Adapter: Curses                */
  2112. /*                                */
  2113. /*    (c) 1991 by Marc Laukien                */
  2114. /*                                */
  2115. /*    Programmteil:    Turnierspiel gegen Computer        */
  2116. /*                                */
  2117. /****************************************************************/
  2118. X
  2119. #include <curses.h>
  2120. #include <stdio.h>
  2121. #include <string.h>
  2122. #include <fcntl.h>
  2123. #include <ctype.h>
  2124. #include <time.h>
  2125. #include <sys/types.h>
  2126. #include "ad.h"
  2127. X
  2128. /****************************************************************/
  2129. /*    Turnierspiel gegen Computer                */
  2130. /****************************************************************/
  2131. X
  2132. void    ad_tc_game()
  2133. X
  2134. {
  2135. X    char     ch;        /* Eingabe            */
  2136. X    char    s[STRLEN];    /* String            */
  2137. X    int    ret;        /* return von domenu        */
  2138. X
  2139. X    /* Pfad zum Speichern    */
  2140. X    sprintf(stdname,"save/%s",wei==0 ? ad_id(getlogin()):
  2141. X    ad_id(gegner));
  2142. X    sprintf(stdname+strlen(stdname),".%s", sch==0 ?
  2143. X    ad_id(getlogin()):ad_id(gegner));
  2144. X
  2145. X    ad_lock();
  2146. X    sprintf(s,"load %s",stdname);
  2147. X    schach(s,ptr);        /* Laden        */
  2148. X    ad_unlock();
  2149. X
  2150. X    schach("info",ptr);    /* Info holen        */
  2151. X    modus = atoi(ptr[9]);    /* merken        */
  2152. X    farbe = ptr[0][0];
  2153. X    level = atoi(ptr[6]);
  2154. X
  2155. X    old_moves = atoi(ptr[1]);    /* Anzahl der Zuege    */
  2156. X
  2157. X    ad_menu();        /* Menue ausgeben    */
  2158. X    ad_brett();        /* Brett aufbauen    */
  2159. X    refresh();        /* ausgeben        */
  2160. X
  2161. X    while(1)
  2162. X    {
  2163. X        /*--- Spielendeueberpruefung ---------------------------*/
  2164. X        if(ende)        /* Spiel zu Ende ?    */
  2165. X        {
  2166. X            switch(ende)
  2167. X            {
  2168. X            case W_AUFG:    /* Weiss gibt auf    */
  2169. X            case W_MATT:     /* Weiss ist matt    */
  2170. X                mvaddstr(2,MPOS,press_key);
  2171. X                move(23,79);
  2172. X                refresh();
  2173. X                ad_read(0,&ch,1);/* einlesen    */
  2174. X                ad_remove();
  2175. X                ad_addscore('B');/* Score     */
  2176. X                break;
  2177. X
  2178. X            case S_AUFG:    /* Schwarz gibt auf    */
  2179. X            case S_MATT:     /* Schwarz ist matt    */
  2180. X                mvaddstr(2,MPOS,press_key);
  2181. X                move(23,79);
  2182. X                refresh();
  2183. X                ad_read(0,&ch,1);/* einlesen    */
  2184. X                ad_remove();
  2185. X                ad_addscore('W');/* Score     */
  2186. X                break;
  2187. X
  2188. X            case PATT:    /* Unentschieden    */
  2189. X                mvaddstr(2,MPOS,press_key);
  2190. X                move(23,79);
  2191. X                refresh();
  2192. X                ad_read(0,&ch,1);/* einlesen    */
  2193. X                ad_remove();
  2194. X                ad_addscore('-');/* Score     */
  2195. X                break;
  2196. X            }
  2197. X
  2198. X            break;        /* Ende         */
  2199. X        }
  2200. X        /*--- Computer -----------------------------------------*/
  2201. SHAR_EOF
  2202. true || echo 'restore of ad/tour_comp.c failed'
  2203. fi
  2204. echo 'End of UnixChess part 3'
  2205. echo 'File ad/tour_comp.c is continued in part 4'
  2206. echo 4 > _shar_seq_.tmp
  2207. exit 0
  2208. -- 
  2209.    /              |    -: Marc Laukien :-     |
  2210.   /__             |                           |   _  _           __
  2211.  /   \  /_  /  /  |   ml@brumuc.muc.sub.org   |  / \/ |   /  /  /
  2212. /____/ /   /__/   | sigma@salyko.doit.sub.org | /     |  /__/  /__
  2213.