ml@brumuc.muc.sub.org (Marc Laukien) (05/20/91)
Submitted-by: ml@brumuc.muc.sub.org
Archive-name: UnixChess/part03
---- Cut Here and feed the following to sh ----
#!/bin/sh
# this is chess.03 (part 3 of UnixChess)
# do not concatenate these parts, unpack them in order with /bin/sh
# file ad/window.c continued
#
if test ! -r _shar_seq_.tmp; then
echo 'Please unpack part 1 first!'
exit 1
fi
(read Scheck
if test "$Scheck" != 3; then
echo Please unpack part "$Scheck" next!
exit 1
else
exit 0
fi
) < _shar_seq_.tmp || exit 1
if test ! -f _shar_wnt_.tmp; then
echo 'x - still skipping ad/window.c'
else
echo 'x - continuing file ad/window.c'
sed 's/^X//' << 'SHAR_EOF' >> 'ad/window.c' &&
X beep();
X }
X while(c!=str[0] && c!=str[1]);
X
X delwin(win); /* Fenster aus */
X win=(WINDOW *)0;
X
X move(23,79);
X touchwin(stdscr);
X wnoutrefresh(stdscr);
X if(setupwin != (WINDOW *)0)
X {
X touchwin(setupwin);
X wnoutrefresh(setupwin);
X }
X doupdate();
X
X if(c==str[0]) /* ja ? */
X return(1);
X else /* nein ? */
X return(0);
}
X
X
SHAR_EOF
echo 'File ad/window.c is complete' &&
chmod 0644 ad/window.c ||
echo 'restore of ad/window.c failed'
Wc_c="`wc -c < 'ad/window.c'`"
test 6749 -eq "$Wc_c" ||
echo 'ad/window.c: original size 6749, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= ad/move.c ==============
if test -f 'ad/move.c' -a X"$1" != X"-c"; then
echo 'x - skipping ad/move.c (File already exists)'
rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
echo 'x - extracting ad/move.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'ad/move.c' &&
/****************************************************************/
/* */
/* XChess V2.7 Adapter: Curses */
/* */
/* (c) 1991 by Marc Laukien */
/* */
/* Programmteil: Zug ausfuehren */
/* */
/****************************************************************/
X
#include <curses.h>
#include <string.h>
#include "ad.h"
X
extern unsigned sleep();
X
/****************************************************************/
/* Zug ausfuehren */
/****************************************************************/
X
void ad_zug(ch)
X
char ch; /* Charakter */
{
X char str[STRLEN]; /* String */
X int i;
X
X strcpy(str,"ziehe "); /* aufbereiten */
X
X move(16,MPOS); /* in Position */
X addstr(domove); /* Meldung */
X addch(ch|A_UNDERLINE); /* ausgeben */
X sprintf(str+strlen(str),"%c",(char)ch); /* aufbereiten */
X refresh();
X
l1: ad_read(0,&ch,1); /* einlesen */
X if(ch=='\b') /* zurueck ? */
X {
X addstr("\b \b");
X str[strlen(str)-1]=0;
X refresh();
X goto l5;
X }
X if(ch<(int)'1' || ch>(int)'8')
X {
X beep();
X goto l1;
X }
X addch(ch|A_UNDERLINE); /* ausgeben */
X sprintf(str+strlen(str),"%c ",(char)ch); /* aufbereiten */
X addch((int)'-'|A_UNDERLINE);
X refresh();
X
l2: ad_read(0,&ch,1); /* einlesen */
X if(ch=='\b') /* zurueck ? */
X {
X addstr("\b \b");
X str[strlen(str)-1]=0;
X addstr("\b \b");
X str[strlen(str)-1]=0;
X refresh();
X goto l1;
X }
X if(ch<(int)'a' || ch>(int)'h')
X {
X beep();
X goto l2;
X }
X addch(ch|A_UNDERLINE); /* ausgeben */
X sprintf(str+strlen(str),"%c",(char)ch); /* aufbereiten */
X refresh();
X
l3: ad_read(0,&ch,1); /* einlesen */
X if(ch=='\b') /* zurueck ? */
X {
X addstr("\b \b");
X str[strlen(str)-1]=0;
X refresh();
X goto l2;
X }
X if(ch<(int)'1' || ch>(int)'8')
X {
X beep();
X goto l3;
X }
X addch(ch|A_UNDERLINE); /* ausgeben */
X sprintf(str+strlen(str),"%c",(char)ch); /* aufbereiten */
X refresh();
X
X schach(str,ptr); /* ziehen */
X if(ptr[0][0]!='?') /* zug ok ? */
X {
X ad_brett();
X farbe= farbe=='w' ? 's':'w';
X /* naechste Farbe */
X }
X else /* falscheingabe */
X beep();
X
l5: move(16,MPOS); /* in Position */
X for(i=MPOS;i<79;i++) /* loschen */
X addstr(" ");
X refresh();
X
X if(TURNGEG())
X {
X ad_lock();
X sprintf(str,"save %s",stdname);
X schach(str,ptr); /* Speichern */
X ad_unlock();
X }
}
X
/****************************************************************/
/* externen Zug ausfuehren */
/****************************************************************/
X
void ad_extzug()
{
X char s[STRLEN];
X int i;
X
X sleep((unsigned)5); /* warten */
X
X ad_lock();
X sprintf(s,"load %s",stdname); /* Pfad zum Laden */
X schach(s,ptr); /* Laden */
X ad_unlock();
X
X if(ptr[0][0]=='?') /* Fehler ? */
X {
X move(3,MPOS);
X
X if(W_IS_USER()) /* Schwarz gab auf */
X {
X attrset(0); /* Alle Attribute aus */
X addstr(b_up); /* Meldung */
X
X ende=S_AUFG;
X }
X
X if(B_IS_USER()) /* Weiss gab auf */
X {
X attrset(0); /* Alle Attribute aus */
X addstr(w_up); /* Meldung */
X
X ende=W_AUFG;
X }
X
X for(i=stdscr->_curx;i<79;i++) /* Rest der Zeile loeschen*/
X mvaddch(stdscr->_cury,i,(int)' ');
X
X }
X else
X {
X ad_brett(); /* Brett aufbauen */
X
X schach("info",ptr); /* Info holen */
X modus = atoi(ptr[9]); /* merken */
X farbe = ptr[0][0];
X level = atoi(ptr[6]);
X
X ad_menu();
X }
}
SHAR_EOF
chmod 0644 ad/move.c ||
echo 'restore of ad/move.c failed'
Wc_c="`wc -c < 'ad/move.c'`"
test 3257 -eq "$Wc_c" ||
echo 'ad/move.c: original size 3257, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= ad/interrupt.c ==============
if test -f 'ad/interrupt.c' -a X"$1" != X"-c"; then
echo 'x - skipping ad/interrupt.c (File already exists)'
rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
echo 'x - extracting ad/interrupt.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'ad/interrupt.c' &&
/****************************************************************/
/* */
/* XChess V2.7 Adapter: Curses */
/* */
/* (c) 1991 by Marc Laukien */
/* */
/* Programmteil: Interrupts */
/* */
/****************************************************************/
X
#include <curses.h>
#include <stdio.h>
#include <signal.h>
#include "ad.h"
X
extern void exit();
X
/****************************************************************/
/* Interrupt */
/****************************************************************/
X
void ad_interrupt()
X
{
X inter=1;
X
X ad_deinit(); /* Deinitialsieren */
X exit(1); /* Ende */
}
X
/****************************************************************/
/* Refresh (^ L) */
/****************************************************************/
X
void ad_refresh()
X
{
X WINDOW *dwin; /* neues Fenster */
X
X signal(SIGUSR1,SIG_IGN);
X signal(SIGALRM,SIG_IGN);
X
X inter=1; /* Interrupt merken */
X
X dwin=newwin(LINES,COLS,0,0);
X wnoutrefresh(dwin); /* ausgeben */
X delwin(dwin); /* Fenster aus */
X
X touchwin(stdscr); /* Fenster ausgeben */
X wnoutrefresh(stdscr);
X if(win != (WINDOW *)0)
X {
X touchwin(win);
X wnoutrefresh(win);
X }
X
X if(setupwin != (WINDOW *)0)
X {
X touchwin(setupwin);
X wnoutrefresh(setupwin);
X }
X
X doupdate();
X
X move(23,79);
X refresh();
X
X signal(SIGUSR1,ad_refresh);
}
X
/****************************************************************/
/* "Best so far" */
/****************************************************************/
X
void ad_break()
X
{
X extern int beende; /* aus ch_ma.c */
X
X inter=1; /* Interrupt merken */
X
X signal(SIGUSR2,SIG_IGN);
X
X if(UEBUNG())
X beende=1; /* beenden */
X
X signal(SIGUSR2,ad_break);
}
X
/****************************************************************/
/* Interrupt starten */
/****************************************************************/
X
void ad_startint()
{
X signal(SIGINT,ad_interrupt); /* Interrupt aendern */
X signal(SIGTERM,ad_interrupt);
X signal(SIGHUP,ad_interrupt);
X
X signal(SIGUSR1,ad_refresh); /* Bild neu aufb. (^ L) */
X signal(SIGUSR2,ad_break); /* "Best so far" */
}
SHAR_EOF
chmod 0644 ad/interrupt.c ||
echo 'restore of ad/interrupt.c failed'
Wc_c="`wc -c < 'ad/interrupt.c'`"
test 2103 -eq "$Wc_c" ||
echo 'ad/interrupt.c: original size 2103, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= ad/load.c ==============
if test -f 'ad/load.c' -a X"$1" != X"-c"; then
echo 'x - skipping ad/load.c (File already exists)'
rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
echo 'x - extracting ad/load.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'ad/load.c' &&
/****************************************************************/
/* */
/* XChess V2.7 Adapter: Curses */
/* */
/* (c) 1991 by Marc Laukien */
/* */
/* Programmteil: Laden & Speichern & Neustart */
/* */
/****************************************************************/
X
#include <curses.h>
#include <stdio.h>
#include <string.h>
#include "ad.h"
X
/****************************************************************/
/* Programm Laden */
/****************************************************************/
X
void ad_load()
X
{
X char str[STRLEN];
X char *s;
X
X if(TURNIER()) /* Turnierspiel ? */
X {
X ad_error(not_allowed);
X return;
X }
X
X s=ad_name('f');
X if(s[strlen(s)-1] != '/')
X if(ad_sure('s'))
X {
X sprintf(str,"load %s",s);
X schach(str,ptr);
X
X if(ptr[0][0]=='?') /* Fehler ? */
X ad_error("");
X else
X {
X ad_brett();
X
X schach("info",ptr);/* Info hol. */
X farbe=ptr[0][0];/* Farbe am Zug */
X if(farbe=='w') /* Farbe einst. */
X {
X wei=0;
X sch=1;
X }
X else
X {
X sch=0;
X wei=1;
X }
X level=atoi(ptr[6]);/* Spielstufe*/
X modus=atoi(ptr[9]);/* Modus */
X ad_menu();
X }
X }
}
X
/****************************************************************/
/* Programm speichern */
/****************************************************************/
X
void ad_save()
X
{
X char str[STRLEN];
X char *s;
X
X if(TURNIER()) /* Turnierspiel ? */
X {
X ad_error(not_allowed);
X return;
X }
X
X s=ad_name('f');
X if(s[strlen(s)-1] != '/')
X {
X sprintf(str,"save %s",s);
X schach(str,ptr);
X if(ptr[0][0]=='?') /* Fehler ? */
X ad_error("");
X }
}
X
/****************************************************************/
/* Zurueck */
/****************************************************************/
X
void ad_zurueck()
X
{
X if(TURNIER()) /* Turnierspiel ? */
X {
X ad_error(not_allowed);
X return;
X }
X
X schach("zurueck",ptr);
X ad_brett();
X schach("info",ptr);/* Info hol. */
X farbe=ptr[0][0];/* Farbe am Zug */
X
X if(farbe=='w') /* Farbe einst. */
X {
X wei=0;
X sch=1;
X }
X else
X {
X sch=0;
X wei=1;
X }
X level=atoi(ptr[6]); /* Spielstufe */
X ad_menu();
}
SHAR_EOF
chmod 0644 ad/load.c ||
echo 'restore of ad/load.c failed'
Wc_c="`wc -c < 'ad/load.c'`"
test 2094 -eq "$Wc_c" ||
echo 'ad/load.c: original size 2094, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= ad/menu.c ==============
if test -f 'ad/menu.c' -a X"$1" != X"-c"; then
echo 'x - skipping ad/menu.c (File already exists)'
rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
echo 'x - extracting ad/menu.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'ad/menu.c' &&
/****************************************************************/
/* */
/* XChess V2.7 Adapter: Curses */
/* */
/* (c) 1991 by Marc Laukien */
/* */
/* Programmteil: Spielmenue */
/* */
/****************************************************************/
X
#include <curses.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <ctype.h>
#include <time.h>
#include <sys/types.h>
#include "ad.h"
X
/****************************************************************/
/* Spielmenue */
/****************************************************************/
X
void ad_game()
X
{
X char s[STRLEN]; /* String */
X
X if(!UEBUNG()) /* Spiel gegen sich selbst ? */
X {
X strcpy(s,ad_id(gegner));
X if(!strcmp(s,ad_id(getlogin())))
X return;
X }
X
X if(!UEBUNG() && !strcmp(ad_id(gegner),"?"))
X { /* Existiert Gegner ? */
X ad_error(no_user);
X return;
X }
X
X ad_game_screen(); /* Bildaufbau */
X
X ad_new(); /* neues Spiel */
X
X if(UEBUNG()) /* Training ? */
X ad_tr_game();
X else if(TURNGEG()) /* Turnier gegen Gegner ? */
X ad_tu_game();
X else /* Turnier gegen Computer ? */
X ad_tc_game();
}
X
/****************************************************************/
/* Menueeingabe */
/****************************************************************/
/* Return: 1: ok 0: Ende */
/* 2: Aufgeben */
/****************************************************************/
X
int ad_domenu(ch)
X
char ch;
{
X if(ch<='h' && ch>='a' && !ende && /*** ziehen ***/
X ((farbe=='w' && W_IS_USER()) || (farbe=='s' && B_IS_USER())))
X ad_zug(ch);
X else if(ch==menu[0][0]) /*** Level ***/
X {
X char str[STRLEN];
X
X if(TURNIER()) /* Turnierspiel */
X ad_error(not_allowed);
X else
X {
X level++;
X if(level >=10)
X level=0;
X ad_menu();
X
X sprintf(str,"stufe %d",level);
X schach(str,ptr);
X }
X }
X else if(ch==menu[1][0]) /*** Weiss ***/
X {
X if(TURNIER()) /* Turnierspiel ? */
X ad_error(not_allowed);
X else
X {
X wei= W_IS_USER();
X ad_menu();
X }
X }
X else if(ch==menu[2][0]) /*** Schwarz ***/
X {
X if(TURNIER()) /* Turnierspiel ? */
X ad_error(not_allowed);
X else
X {
X sch= B_IS_USER();
X ad_menu();
X }
X }
X else if(ch==menu[3][0]) /*** Analyse ***/
X {
X char str[STRLEN];
X
X if(TURNGEG()) /* ext. Gegner */
X ad_error(not_allowed);
X else
X {
X schach("info",ptr); /* Info hol. */
X modus=atoi(ptr[9]); /* Modus */
X modus ^= 128; /* aendern */
X sprintf(str,"modus %d",modus);
X schach(str,ptr); /* setzen */
X if(!(modus & 128)) /* aus ? */
X ad_analyse(" a b c d e f g h");
X ad_menu();
X }
X }
X else if(ch==menu[4][0]) /*** Setup ***/
X ad_setup();
X else if(ch==menu[5][0]) /*** Zurueck ***/
X ad_zurueck();
X else if(ch==menu[6][0]) /*** Info ***/
X ad_info();
X else if(ch==menu[7][0]) /*** Neustart ***/
X {
X return(2);
X }
X else if(ch==menu[8][0]) /*** ende ***/
X {
X if(ad_sure('s'))
X return(0);
X }
#ifdef EXT_ANALYSE /* gesperrt ! */
X else if(ch==(char)26) /*** ausf. Analyse ***/
X { /* ^ Z */
X char str[STRLEN];
X
X schach("info",ptr); /* Info hol. */
X modus=atoi(ptr[9]); /* Modus */
X modus ^= 1; /* aendern */
X sprintf(str,"modus %d",modus);
X schach(str,ptr); /* setzen */
X if(!(modus & 1)) /* aus ? */
X ad_analyse(" a b c d e f g h");
X }
#endif
X else if(ch!=' ') /* Space wird ignoriert */
X beep(); /*** Fehler ***/
X
X return(1);
}
SHAR_EOF
chmod 0644 ad/menu.c ||
echo 'restore of ad/menu.c failed'
Wc_c="`wc -c < 'ad/menu.c'`"
test 3404 -eq "$Wc_c" ||
echo 'ad/menu.c: original size 3404, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= ad/lock.c ==============
if test -f 'ad/lock.c' -a X"$1" != X"-c"; then
echo 'x - skipping ad/lock.c (File already exists)'
rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
echo 'x - extracting ad/lock.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'ad/lock.c' &&
/****************************************************************/
/* */
/* XChess V2.7 Adapter: Curses */
/* */
/* (c) 1991 by Marc Laukien */
/* */
/* Programmteil: File Locking */
/* */
/****************************************************************/
X
#include <curses.h>
#include <stdio.h>
#include <fcntl.h>
#include "ad.h"
X
extern unsigned sleep();
X
/****************************************************************/
/* File locken */
/****************************************************************/
X
void ad_lock()
X
{
X int fd;
X char str[STRLEN];
X
X if(!TURNGEG()) /* Computer = Gegner ? */
X return; /* Kein lock noetig */
X
X sprintf(str,"%s.lock",stdname); /* Pfad aufbereiten */
X
X while(1)
X {
X fd=open(str,O_WRONLY | O_CREAT | O_EXCL,0664); /* Lock holen */
X
X if(fd!=-1) /* nicht locked ? */
X break;
X
X sleep((unsigned)2);
X }
X
X close(fd); /* schliessen */
X
X lock=1;
}
X
/****************************************************************/
/* File unlocken */
/****************************************************************/
X
void ad_unlock()
X
{
X char str[STRLEN]; /* String fuer Pfad- und Dateinamen */
X
X if(!TURNGEG()) /* Computer = Gegner ? */
X return; /* Kein lock noetig */
X
X sprintf(str,"%s.lock",stdname); /* Pfad aufbereiten */
X if(unlink(str) == -1) /* loeschen */
X ad_error("");
X
X lock=0;
}
X
/****************************************************************/
/* Score locken */
/****************************************************************/
X
void ad_locksc()
X
{
X int fd;
X static char *str="score.lock";
X
X while(1)
X {
X fd=open(str,O_WRONLY | O_CREAT | O_EXCL,0664); /* Lock holen */
X
X if(fd!=-1) /* nicht locked ? */
X break;
X
X sleep((unsigned)2);
X }
X
X close(fd); /* schliessen */
X
X lock=1;
}
X
/****************************************************************/
/* Score unlocken */
/****************************************************************/
X
void ad_unlocksc()
X
{
X if(unlink("score.lock") == -1) /* loeschen */
X ad_error("");
X
X lock=0;
}
X
SHAR_EOF
chmod 0644 ad/lock.c ||
echo 'restore of ad/lock.c failed'
Wc_c="`wc -c < 'ad/lock.c'`"
test 2071 -eq "$Wc_c" ||
echo 'ad/lock.c: original size 2071, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= ad/admin.c ==============
if test -f 'ad/admin.c' -a X"$1" != X"-c"; then
echo 'x - skipping ad/admin.c (File already exists)'
rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
echo 'x - extracting ad/admin.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'ad/admin.c' &&
/****************************************************************/
/* */
/* XChess V2.7 Adapter: Curses */
/* */
/* (c) 1991 by Marc Laukien */
/* */
/* Programmteil: Administrationsmenue */
/* */
/****************************************************************/
X
#include <sys/types.h>
#include <dirent.h>
#include <string.h>
#include <curses.h>
#include <stdio.h>
#include <ctype.h>
X
#include "ad.h"
X
/****************************************************************/
/* Menueeingabe */
/****************************************************************/
X
void ad_admin()
X
{
X char ch; /* Zeichen zum Einlesen */
X
X ad_admin_screen(); /* Bildaufbau */
X ad_amenu();
X move(23,79);
X refresh(); /* ausgeben */
X
X while(1)
X {
X ad_read(0,&ch,1); /* einlesen */
X if(isupper(ch)) /* gross ? */
X ch=tolower(ch);
X
X ad_flush(); /* restliche Zeichen wegwerfen */
X
X
X if(ch==amenu[0][0]) /*** Uebungsspiel ***/
X {
X gegner[0]=0; /* Computer ist Gegner */
X ad_game();
X
X ad_admin_screen(); /* Bildaufbau */
X ad_amenu();
X move(23,79);
X refresh(); /* ausgeben */
X }
X else if(ch==amenu[1][0]) /*** Trainingssp. zeigen ***/
X {
X ad_uliste();
X
X ad_admin_screen(); /* Bildaufbau */
X ad_amenu();
X move(23,79);
X refresh(); /* ausgeben */
X }
X else if(ch==amenu[2][0]) /*** Trainingssp. loeschen ***/
X {
X char *s;
X char str[STRLEN*2];
X
X s=ad_name('f');
X
X sprintf(str,"%s.ch",s);
X if(unlink(str) == -1) /* loeschen */
X ad_error("");
X
X ad_admin_screen(); /* Bildaufbau */
X ad_amenu();
X move(23,79);
X refresh(); /* ausgeben */
X }
X else if(ch==amenu[3][0]) /*** Weiss gegen Comp. ***/
X {
X strcpy(gegner,"~");
X wei=0;
X sch=1;
X ad_game();
X
X ad_admin_screen(); /* Bildaufbau */
X ad_amenu();
X move(23,79);
X refresh(); /* ausgeben */
X }
X else if(ch==amenu[4][0]) /*** Schw. gegen Comp. ***/
X {
X strcpy(gegner,"~");
X wei=1;
X sch=0;
X ad_game();
X
X ad_admin_screen(); /* Bildaufbau */
X ad_amenu();
X move(23,79);
X refresh(); /* ausgeben */
X }
X else if(ch==amenu[5][0]) /*** Weiss gegen Spieler ***/
X {
X strcpy(gegner,ad_name('g'));
X if(gegner[0]=='\0') /* Kein Gegner ? */
X continue;
X wei=0;
X sch=1;
X ad_game();
X
X ad_admin_screen(); /* Bildaufbau */
X ad_amenu();
X move(23,79);
X refresh(); /* ausgeben */
X }
X else if(ch==amenu[6][0]) /*** Schw. gegen Spieler ***/
X {
X strcpy(gegner,ad_name('g'));
X if(gegner[0]=='\0') /* Kein Gegner ? */
X continue;
X wei=1;
X sch=0;
X ad_game();
X
X ad_admin_screen(); /* Bildaufbau */
X ad_amenu();
X move(23,79);
X refresh(); /* ausgeben */
X }
X else if(ch==amenu[7][0]) /*** Turniersp. zeigen ***/
X {
X ad_tliste();
X
X ad_admin_screen(); /* Bildaufbau */
X ad_amenu();
X move(23,79);
X refresh(); /* ausgeben */
X }
X else if(ch==amenu[8][0]) /*** Highscoreliste zeigen ***/
X {
X ad_showscore();
X
X ad_admin_screen(); /* Bildaufbau */
X ad_amenu();
X move(23,79);
X refresh(); /* ausgeben */
X }
X else if(ch==amenu[9][0]) /*** Ende ***/
X {
X if(ad_sure('s'))
X break;
X }
X else if(ch!=' ') /* Space wird ign. */
X beep(); /*** Fehler ***/
X }
}
X
/****************************************************************/
/* Turnierspielliste */
/****************************************************************/
X
void ad_tliste()
X
{
X char c;
X int i,j,y=2;
X DIR *dir; /* Directory - Pointer */
X struct dirent *dp; /* Pointer auf Eintrag */
X char str[STRLEN],str2[STRLEN]; /* String */
X char *s[3];
X
X ad_admin_screen(); /* Bildaufbau */
X attrset(A_UNDERLINE|A_BOLD); /* Unterstreichen und Hell */
X mvaddstr(y,1,tlist);
X attrset(0); /* Attribute aus */
X
X if( (dir=opendir("save"))==(DIR *)0 ) /* oeffnen */
X {
X ad_error(""); /* Fehler */
X return;
X }
X
X while( (dp=readdir(dir)) != (struct dirent *)0 ) /* Ende ? */
X {
X strcpy(str,dp->d_name); /* kopieren */
X
X i=0;
X j=0;
X s[j++]=str;
X while(str[i]!='\0') /* String aufbereiten */
X {
X if(str[i]=='.')
X {
X str[i++]='\0'; /* beenden */
X s[j++]=str+i;
X }
X
X if(j>=3)
X break;
X
X i++;
X }
X
X if(j==3) /* Spiel gefunden ? */
X {
X if(y==21) /* Bildschirmende ? */
X {
X attrset(A_BOLD);/* Hell */
X mvaddstr(++y,ADM_RAND,press_key); /* TASTE */
X move(23,79);
X refresh(); /* ausgeben */
X
X ad_read(0,&c,1); /* auf Taste warten */
X
X ad_admin_screen(); /* Bildaufbau */
X
X y=2;
X attrset(A_UNDERLINE|A_BOLD);
X mvaddstr(y,1,tlist);
X attrset(0); /* Attribute aus */
X }
X
X if(!strcmp(ad_id(getlogin()),s[0]))
X attrset(A_BOLD); /* Hell */
X else
X attrset(0); /* Normal */
X mvaddstr(++y,ADM_RAND,ad_revid(s[0]));
X /* ausgeben */
X
X if(!strcmp(ad_id(getlogin()),s[1]))
X attrset(A_BOLD); /* Hell */
X else
X attrset(0); /* Normal */
X mvaddstr(y,ADM_RAND+15,ad_revid(s[1]));
X /* ausgeben */
X
X sprintf(str2,"loadinfo save/%s.%s",s[0],s[1]);
X /* Kommandostring */
X schach(str2,ptr); /* Info anfordern */
X
X if(!strcmp(ad_id(getlogin()),ptr[0][0]=='w' ? s[0]:s[1]))
X attrset(A_BOLD|A_BLINK);/* Hell & Blink */
X else
X attrset(0); /* Normal */
X
X mvaddstr(y,ADM_RAND+30,ptr[1]); /* Zuege */
X /* Farbe */
X mvaddstr(y,ADM_RAND+45,ptr[0][0]=='w' ? white:black);
X
X refresh();
X }
X }
X
X closedir(dir);
X
X attrset(A_BOLD); /* Hell */
X mvaddstr(++y,ADM_RAND,press_key); /* TASTE */
X move(23,79);
X refresh(); /* ausgeben */
X
X ad_read(0,&c,1); /* auf Taste warten */
}
X
/****************************************************************/
/* Trainingsspielliste */
/****************************************************************/
X
void ad_uliste()
X
{
X char c;
X int i,j,y=2;
X DIR *dir; /* Directory - Pointer */
X struct dirent *dp; /* Pointer auf Eintrag */
X char str[STRLEN],str2[STRLEN]; /* String */
X char *s[3];
X
X ad_admin_screen(); /* Bildaufbau */
X attrset(A_UNDERLINE|A_BOLD); /* Unterstreichen und Hell */
X mvaddstr(y,1,ulist);
X attrset(0); /* Attribute aus */
X
X if( (dir=opendir("training"))==(DIR *)0 ) /* oeffnen */
X {
X ad_error(""); /* Fehler */
X return;
X }
X
X while( (dp=readdir(dir)) != (struct dirent *)0 ) /* Ende ? */
X {
X strcpy(str,dp->d_name); /* kopieren */
X
X i=0;
X j=0;
X s[j++]=str;
X while(str[i]!='\0') /* String aufbereiten */
X {
X if(str[i]=='.')
X {
X str[i++]='\0'; /* beenden */
X s[j++]=str+i;
X }
X
X if(j>=3)
X break;
X
X i++;
X }
X
X if(j==3) /* Spiel gefunden ? */
X {
X if(y==21) /* Bildschirmende ? */
X {
X attrset(A_BOLD);/* Hell */
X mvaddstr(++y,ADM_RAND,press_key); /* TASTE */
X move(23,79);
X refresh(); /* ausgeben */
X
X ad_read(0,&c,1); /* auf Taste warten */
X
X ad_admin_screen(); /* Bildaufbau */
X
X y=2;
X attrset(A_UNDERLINE|A_BOLD);
X mvaddstr(y,1,ulist);
X attrset(0); /* Attribute aus */
X }
X
X attrset(0); /* Attribute aus */
X
X if(strcmp(s[0],ad_id(getlogin())))
X /* Anderer Spieler ? */
X continue;
X
X mvaddstr(++y,ADM_RAND,ad_revid(s[0]));
X mvaddstr(y,ADM_RAND+15,s[1]); /* ausgeben */
X
X sprintf(str2,"loadinfo training/%s.%s",s[0],s[1]);
X /* Kommandostring */
X schach(str2,ptr); /* Info anfordern */
X
X mvaddstr(y,ADM_RAND+30,ptr[1]); /* Zuege */
X /* Farbe */
X mvaddstr(y,ADM_RAND+45,ptr[0][0]=='w' ? white:black);
X
X refresh();
X }
X }
X
X closedir(dir);
X
X attrset(A_BOLD); /* Hell */
X mvaddstr(++y,ADM_RAND,press_key); /* TASTE */
X move(23,79);
X refresh(); /* ausgeben */
X
X ad_read(0,&c,1); /* auf Taste warten */
}
X
SHAR_EOF
chmod 0644 ad/admin.c ||
echo 'restore of ad/admin.c failed'
Wc_c="`wc -c < 'ad/admin.c'`"
test 7463 -eq "$Wc_c" ||
echo 'ad/admin.c: original size 7463, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= ad/screen.c ==============
if test -f 'ad/screen.c' -a X"$1" != X"-c"; then
echo 'x - skipping ad/screen.c (File already exists)'
rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
echo 'x - extracting ad/screen.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'ad/screen.c' &&
/****************************************************************/
/* */
/* XChess V2.7 Adapter: Curses */
/* */
/* (c) 1991 by Marc Laukien */
/* */
/* Programmteil: Bildschirmaufbau */
/* */
/****************************************************************/
X
#include <curses.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <ctype.h>
X
#include "ad.h"
#include "patchlevel.h"
X
/****************************************************************/
/* Spielmenue-Screen */
/****************************************************************/
X
void ad_game_screen()
X
{
X int x,y;
X int ch;
X
X attrset(0); /* Alle Attribute aus */
X erase(); /* loeschen */
X
X for(x=0;x<8*5;x++) /* Alle Felder aufbauen */
X for(y=0;y<8*3;y++)
X { /* schwarz oder weiss ? */
X if(y==0 || y==23) /* oberste o. unterste */
X { /* Reihe ? */
X if(!((x-2)%5)) /* Beschriftung ? */
X ch=(x+2)/5+(int)'a'|A_REVERSE;
X else /* Keine Beschriftung */
X ch=(int)' '|A_REVERSE;
X }
X else
X ch=(int)' '|A_BOLD; /* Normales Feld */
X
X if(!((x/5)%2) ^ ((y/3)%2)) /* schw. Feld ? */
X ch |= A_REVERSE;
X
X mvaddch(y,x+1,ch); /* eintragen */
X }
X
X for(y=0;y<8*3;y++) /* Linie ziehen */
X {
X if(!((y-1)%3)) /* Beschriftung ? */
X ch=7-(y+1)/3+(int)'1'|A_REVERSE;
X else /* Keine Beschriftung */
X ch=(int)' '|A_REVERSE;
X
X mvaddch(y,8*5+1,ch);
X mvaddch(y,0,ch);
X }
X
X attrset(A_REVERSE); /* Invers ein */
X mvaddstr(0 ,2+5*8,"UNIX-Chess V2.7 (c) 1991 by M.Laukien ");
X attrset(0);
X
X attrset(A_REVERSE); /* Invers ein */
X mvaddstr(18,2+5*8," ");
X addstr(figlist); /* Geschlagene Figuren */
X for(x=stdscr->_curx;x<79;x++)
X addstr(" ");
X attrset(0);
X
X for(y=0;y<23;y++) /* Rand */
X mvaddch(y,79,(int)' '|A_REVERSE);
X
X for(x=2+5*8;x<79;x++) /* Rand */
X mvaddch(23,x,(int)' '|A_REVERSE);
}
X
/****************************************************************/
/* Spielmenue ausgeben */
/****************************************************************/
X
void ad_menu()
X
{
X int y=4; /* Koordinaten */
X int x;
X char str[STRLEN]; /* String */
X char c1=' ',c2=' ';
X
X attrset(0); /* Alle Attribute aus */
X
X if(TURNIER()) /* Turnierspiel ? */
X c1='*';
X
X sprintf(str,"%c%s%d",c1,menu[0]+1,level+1);/* LEVEL */
X mvaddstr(++y,MPOS-1,str);
X for(x=stdscr->_curx;x<79;x++) /* Rest der Zeile loeschen */
X mvaddch(y,x,(int)' ');
X sprintf(str,"%c%s%s",c1,menu[1]+1,wei ?
X (TURNGEG() ? gegner:comp) :getlogin());
X mvaddstr(++y,MPOS-1,str); /* WEISS */
X for(x=stdscr->_curx;x<79;x++) /* Rest der Zeile loeschen */
X mvaddch(y,x,(int)' ');
X sprintf(str,"%c%s%s",c1,menu[2]+1,sch ?
X (TURNGEG() ? gegner:comp) :getlogin());
X mvaddstr(++y,MPOS-1,str); /* SCHWARZ */
X for(x=stdscr->_curx;x<79;x++) /* Rest der Zeile loeschen */
X mvaddch(y,x,(int)' ');
X if(TURNGEG())
X sprintf(str,"%c%s%s",c1,menu[3]+1,modus & 128 ? ison:isoff);
X else
X sprintf(str,"%c%s%s%c",' ',menu[3]+1,modus & 128 ? ison:isoff,' ');
X mvaddstr(++y,MPOS-1,str); /* ANALYSE */
X for(x=stdscr->_curx;x<79;x++) /* Rest der Zeile loeschen */
X mvaddch(y,x,(int)' ');
X sprintf(str,"%c%s",c1,menu[4]+1);
X mvaddstr(++y,MPOS-1,str); /* SETUP */
X sprintf(str,"%c%s",c1,menu[5]+1);
X mvaddstr(++y,MPOS-1,str); /* ZURUECK */
X sprintf(str," %s ",menu[6]+1);
X mvaddstr(++y,MPOS-1,str); /* INFO */
X sprintf(str," %s ",menu[7]+1);
X mvaddstr(++y,MPOS-1,str); /* NEUSTART */
X sprintf(str," %s ",menu[8]+1);
X mvaddstr(++y,MPOS-1,str); /* ENDE */
X sprintf(str,"%c%s",c1,menu[9]+1);
X mvaddstr(++y,MPOS-1,str); /* BREAK */
X
}
X
/****************************************************************/
/* Adm.-Menue-Screen */
/****************************************************************/
X
void ad_admin_screen()
X
{
X int x,y;
X char *header1=
"UNIX-Chess V2.7 PL%-2d (c) 1991 by Marc Laukien ";
X char *header2=
"Opening-Library (c) 1990 by Christoph Thommes";
X char str[STRLEN];
X
X sprintf(str,header1,PATCHLEVEL);/* aufbereiten */
X
X attrset(0); /* Alle Attribute aus */
X erase(); /* loeschen */
X
X for(x=0;x<79;x++) /* Bildschirmrand aufb. */
X {
X mvaddch(0,x,(int)' '|A_REVERSE);
X mvaddch(1,x,(int)' '|A_REVERSE);
X mvaddch(23,x,(int)' '|A_REVERSE);
X }
X
X for(y=0;y<23;y++) /* Bildschirmrand aufb. */
X {
X mvaddch(y,0,(int)' '|A_REVERSE);
X mvaddch(y,79,(int)' '|A_REVERSE);
X }
X
X attrset(A_REVERSE); /* Invers ein */
X mvaddstr(0 ,ADM_RAND,str);
X mvaddstr(1 ,ADM_RAND,header2);
}
X
/****************************************************************/
/* Adm.-Menue ausgeben */
/****************************************************************/
X
void ad_amenu()
X
{
X int x,y=3; /* Koordinaten */
X char str[STRLEN];
X
X attrset(A_BOLD); /* Hell ein */
X
X sprintf(str,"%s",amenu[0]+1);
X mvaddstr(y,ADM_RAND,str); /* TRAINING */
X sprintf(str,"%s",amenu[1]+1);
X mvaddstr(++y,ADM_RAND,str); /* ZEIGE TRAININGSSP. */
X sprintf(str,"%s",amenu[2]+1);
X mvaddstr(++y,ADM_RAND,str); /* LOESCHE TRAININGSSP. */
X
X attrset(A_NORMAL); /* Hell aus */
X
X y+=2;
X for(x=1;x<79;x++) /* Trennstrich aufb. */
X mvaddch(y,x,(int)'-'|A_NORMAL);
X
X attrset(A_BOLD); /* Hell ein */
X
X sprintf(str,"%s",amenu[3]+1);
X mvaddstr(y+=2,ADM_RAND,str); /* TURNIER WEISS COMP */
X sprintf(str,"%s",amenu[4]+1);
X mvaddstr(++y,ADM_RAND,str); /* TURNIER SCHWARZ COMP */
X sprintf(str,"%s",amenu[5]+1);
X mvaddstr(y+=2,ADM_RAND,str); /* TURNIER WEISS */
X sprintf(str,"%s",amenu[6]+1);
X mvaddstr(++y,ADM_RAND,str); /* TURNIER SCHWARZ */
X sprintf(str,"%s",amenu[7]+1);
X mvaddstr(y+=2,ADM_RAND,str); /* ZEIGE TURNIERSP. */
X sprintf(str,"%s",amenu[8]+1);
X mvaddstr(++y,ADM_RAND,str); /* ZEIGE HIGHSCORE */
X
X attrset(A_NORMAL); /* Hell aus */
X
X y+=2;
X for(x=1;x<79;x++) /* Trennstrich aufb. */
X mvaddch(y,x,(int)'-'|A_NORMAL);
X
X attrset(A_BOLD); /* Hell ein */
X
X sprintf(str,"%s",amenu[9]+1);
X mvaddstr(y+=2,ADM_RAND,str); /* ENDE */
}
X
X
SHAR_EOF
chmod 0644 ad/screen.c ||
echo 'restore of ad/screen.c failed'
Wc_c="`wc -c < 'ad/screen.c'`"
test 5856 -eq "$Wc_c" ||
echo 'ad/screen.c: original size 5856, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= ad/id.c ==============
if test -f 'ad/id.c' -a X"$1" != X"-c"; then
echo 'x - skipping ad/id.c (File already exists)'
rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
echo 'x - extracting ad/id.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'ad/id.c' &&
/****************************************************************/
/* */
/* XChess V2.7 Adapter: Curses */
/* */
/* (c) 1991 by Marc Laukien */
/* */
/* Programmteil: Spieler-ID liefern */
/* */
/****************************************************************/
X
#include <curses.h>
#include <pwd.h>
#include "ad.h"
X
/****************************************************************/
/* String mit ID zu Username liefern */
/****************************************************************/
/* Return: String mit ID */
/****************************************************************/
X
char *ad_id(name)
X
char *name;
{
X static char id[STRLEN];
X struct passwd *pwd;
X
X if(name[0]=='~' || strcmp(name,comp)==0) /* Rechner ? */
X return("~");
X
X pwd=getpwnam(name); /* Passwordeintrag holen */
X
X if(pwd!=(struct passwd *)0) /* Kein 0-Pointer ? */
X sprintf(id,"%d",pwd->pw_uid);
X else
X strcpy(id,"?");
X
X return(id);
}
X
/****************************************************************/
/* String mit Username zu ID liefern */
/****************************************************************/
/* Return: String mit Username */
/****************************************************************/
X
char *ad_revid(id)
X
char *id;
{
X static char name[STRLEN];
X struct passwd *pwd;
X
X if(id[0]=='~') /* Rechner ? */
X return(comp);
X
X pwd=getpwuid(atoi(id)); /* Passwordeintrag holen */
X
X if(pwd!=(struct passwd *)0) /* Kein 0-Pointer ? */
X sprintf(name,"%s",pwd->pw_name);
X else
X sprintf(name,"%s",id);
X
X return(name);
}
X
X
SHAR_EOF
chmod 0644 ad/id.c ||
echo 'restore of ad/id.c failed'
Wc_c="`wc -c < 'ad/id.c'`"
test 1569 -eq "$Wc_c" ||
echo 'ad/id.c: original size 1569, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= ad/score.c ==============
if test -f 'ad/score.c' -a X"$1" != X"-c"; then
echo 'x - skipping ad/score.c (File already exists)'
rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
echo 'x - extracting ad/score.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'ad/score.c' &&
/****************************************************************/
/* */
/* XChess V2.7 Adapter: Curses */
/* */
/* (c) 1991 by Marc Laukien */
/* */
/* Programmteil: Highscore */
/* */
/****************************************************************/
X
#include <curses.h>
#include <stdio.h>
#include <string.h>
#include <memory.h>
#include "ad.h"
X
/****************************************************************/
/* Highscoreeintrag anhaengen */
/****************************************************************/
X
void ad_addscore(stat)
X
char stat; /* Status */
{
X FILE *fp;
X long ti;
X
X ad_locksc(); /* locken */
X
X if((fp=fopen("score.list","a"))==(FILE *)0) /* oeffnen */
X {
X ad_error("");
X return;
X }
X
X ti=time((long *)0);
X
X fprintf(fp,"%c %s ",
X stat,
X wei==0 ? ad_id(getlogin()):ad_id(gegner));
X
X fprintf(fp,"%s ",
X sch==0 ? ad_id(getlogin()):ad_id(gegner));
X
X fprintf(fp,"# %s vs. %s %s",
X wei==0 ? getlogin(): gegner[0]=='~' ? comp:gegner,
X sch==0 ? getlogin(): gegner[0]=='~' ? comp:gegner,
X ctime(&ti)); /* Datum */
X
X fclose(fp); /* schliessen */
X
X ad_unlocksc(); /* unlocken */
}
X
/****************************************************************/
/* Highscoreeintrag anhaengen fuer expire */
/****************************************************************/
X
void ad_addscore_expire(stat,white,black)
X
char stat; /* Status */
char *white,*black; /* Spieler */
{
X FILE *fp;
X long ti;
X
X ad_locksc(); /* locken */
X
X if((fp=fopen("score.list","a"))==(FILE *)0) /* oeffnen */
X {
X ad_error("");
X return;
X }
X
X ti=time((long *)0);
X
X fprintf(fp,"%c %s ",stat,ad_id(white));
X fprintf(fp,"%s ",ad_id(black));
X
X fprintf(fp,"# (exp) %s vs. %s %s",white,black,ctime(&ti));
X /* Kommentar */
X
X fclose(fp); /* schliessen */
X
X ad_unlocksc(); /* unlocken */
}
X
/****************************************************************/
/* Highscore ausgeben */
/****************************************************************/
X
void ad_showscore()
X
{
X FILE *fp;
X char c,s1[STRLEN],s2[STRLEN],str[STRLEN];
X int i,j,y=2,nr=0;
X char *my_id;
X
X struct
X {
X char id[7]; /* User-ID */
X double score; /* Punkte */
X int nr; /* Anzahl der Spiele */
X int comp; /* Davon gegen den Computer */
X } score[1000],copy;
X
X if((fp=fopen("score.list","r"))==(FILE *)0) /* oeffnen */
X {
X ad_error("");
X return;
X }
X
X while(!feof(fp) && nr<1000) /* Dateiende ? */
X {
X if(fgets(str,STRLEN,fp)==(char *)0) /* einlesen */
X continue;
X sscanf(str,"%c %s %s",&c,s1,s2);
X
X for(i=0;i<nr;i++) /* Spieler 1 suchen */
X if(!strcmp(score[i].id,s1))
X break;
X
X if(i==nr) /* Neueintrag ? */
X {
X strcpy(score[i].id,s1); /* Name kopieren */
X score[i].score=1000.0; /* Punkte */
X score[i].nr=0;
X score[i].comp=0;
X nr++;
X }
X
X for(j=0;j<nr;j++) /* Spieler 2 suchen */
X if(!strcmp(score[j].id,s2))
X break;
X
X if(j==nr) /* Neueintrag ? */
X {
X strcpy(score[j].id,s2); /* Name kopieren */
X score[j].score=1000.0; /* Punkte */
X score[j].nr=0;
X score[j].comp=0;
X nr++;
X }
X
X score[i].nr++; /* Ein Spiel mehr */
X score[j].nr++;
X
X if(s1[0] == '~') /* Computer ? */
X score[j].comp++;
X if(s2[0] == '~')
X score[i].comp++;
X
X switch(c) /* Score veraendern */
X {
X case 'w': /* Gewinn Weiss */
X case 'W':
X score[i].score += score[j].score/4;
X score[j].score -= score[j].score/4;
X break;
X
X case 'b': /* Gewinn Schwarz */
X case 'B':
X score[j].score += score[i].score/4;
X score[i].score -= score[i].score/4;
X break;
X }
X }
X
X fclose(fp);
X
X ad_admin_screen(); /* Bildaufbau */
X attrset(A_UNDERLINE|A_BOLD); /* Unterstreichen und Hell */
X mvaddstr(y,1,scorelist);
X attrset(0); /* Attribute aus */
X
X for(i=0 ;i<nr-1;i++) /* sortieren */
X for(j=i+1;j<nr ;j++)
X if(score[i].score < score[j].score)
X {
X memcpy((char *)©,(char *)&score[i],sizeof(copy));
X memcpy((char *)&score[i],(char *)&score[j],sizeof(copy));
X memcpy((char *)&score[j],(char *)©,sizeof(copy));
X }
X
X my_id=ad_id(getlogin()); /* ID des Benutzers */
X
X for(i=0;i<nr;i++)
X {
X if(y==21) /* Bildschirmende ? */
X {
X attrset(A_BOLD);/* Hell */
X mvaddstr(++y,ADM_RAND,press_key); /* TASTE */
X move(23,79);
X refresh(); /* ausgeben */
X
X ad_read(0,&c,1); /* auf Taste warten */
X
X ad_admin_screen(); /* Bildaufbau */
X
X y=2;
X attrset(A_UNDERLINE|A_BOLD);
X mvaddstr(y,1,scorelist);
X attrset(0); /* Attribute aus */
X }
X
X sprintf(s1,"%6.0lf",score[i].score);
X sprintf(s2,"%d",score[i].nr);
X sprintf(str,"%d",score[i].comp);
X
X if(!strcmp(my_id,score[i].id))
X attrset(A_BLINK); /* Blinken */
X else if(i<3) /* Top 3 ? */
X attrset(A_BOLD); /* Hell */
X else
X attrset(0); /* Normal */
X
X mvaddstr(++y,ADM_RAND,ad_revid(score[i].id));
X mvaddstr(y,ADM_RAND+15,s2);
X mvaddstr(y,ADM_RAND+30,str);
X mvaddstr(y,ADM_RAND+45,s1); /* ausgeben */
X }
X
X fclose(fp);
X
X attrset(A_BOLD); /* Hell */
X mvaddstr(++y,ADM_RAND,press_key); /* TASTE */
X move(23,79);
X refresh(); /* ausgeben */
X
X ad_read(0,&c,1); /* auf Taste warten */
}
X
SHAR_EOF
chmod 0644 ad/score.c ||
echo 'restore of ad/score.c failed'
Wc_c="`wc -c < 'ad/score.c'`"
test 5003 -eq "$Wc_c" ||
echo 'ad/score.c: original size 5003, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= ad/training.c ==============
if test -f 'ad/training.c' -a X"$1" != X"-c"; then
echo 'x - skipping ad/training.c (File already exists)'
rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
echo 'x - extracting ad/training.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'ad/training.c' &&
/****************************************************************/
/* */
/* XChess V2.7 Adapter: Curses */
/* */
/* (c) 1991 by Marc Laukien */
/* */
/* Programmteil: Uebungsspiel */
/* */
/****************************************************************/
X
#include <curses.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <ctype.h>
#include <sys/types.h>
#include "ad.h"
X
/****************************************************************/
/* Uebungsspiel */
/****************************************************************/
X
void ad_tr_game()
X
{
X char ch='\0'; /* Eingabe */
X char s[STRLEN]; /* String */
X int ret; /* Return von domenu */
X
X sprintf(stdname,"training/%s.std",ad_id(getlogin()));
X
X ad_lock();
X sprintf(s,"load %s",stdname);
X schach(s,ptr); /* Laden */
X ad_unlock();
X
X schach("info",ptr); /* Info holen */
X modus = atoi(ptr[9]); /* merken */
X farbe = ptr[0][0];
X level = atoi(ptr[6]);
X
X if(farbe=='w') /* Farbe einst. */
X {
X wei=0;
X sch=1;
X }
X else
X {
X sch=0;
X wei=1;
X }
X
X ad_menu(); /* Menue ausgeben */
X ad_brett(); /* Brett aufbauen */
X refresh(); /* ausgeben */
X
X while(1)
X {
X /*--- Computer -----------------------------------------*/
X if(!ende && ((farbe=='w' && wei) || (farbe=='s' && sch)))
X { /* Computerzug */
X int x;
X
X mvaddstr(2,MPOS,thinking);/* Status ausgeben */
X move(23,79);
X refresh();
X
X schach("comp",ptr); /* Zug holen */
X
X ad_brett(); /* Brett aufbauen */
X
X schach("info",ptr); /* Info holen */
X farbe=ptr[0][0]; /* Farbe am Zug */
X
X move(2,MPOS); /* Meldung loeschen */
X for(x=stdscr->_curx;x<79;x++) /* loeschen */
X mvaddch(stdscr->_cury,x,(int)' ');
X }
X else
X /*--- Spieler ------------------------------------------*/
X {
X if(ch=='\0')
X ad_read(0,&ch,1);/* einlesen */
X
X if(isupper(ch)) /* gross ? */
X ch=tolower(ch);
X
X ad_flush(); /* restliche Zeichen wegwerfen */
X
X ret=ad_domenu(ch); /* auswerten */
X
X if(ret==0) /* Ende ? */
X {
X ad_lock();
X sprintf(s,"save %s",stdname);
X schach(s,ptr); /* Speichern */
X ad_unlock();
X break;
X }
X else if(ret==2) /* Neustart ? */
X {
X if(ad_sure('s'))
X ad_new();
X }
X }
X
X ch='\0';
X
X /*--- Abbruch der Demo ---------------------------------*/
X
X if(wei && sch) /* Demo ? */
X {
X int flags; /* Flags fuer ad_read() */
X int ret;
X
X flags=fcntl(0,F_GETFL,0); /* flags retten */
X
X fcntl(0,F_SETFL,flags | O_NDELAY); /* block aus */
X ret=ad_read(0,&ch,1); /* einlesen */
X fcntl(0,F_SETFL,flags & ~O_NDELAY);/* block ein */
X
X ad_flush(); /* restliche Zeichen wegwerfen */
X if(ret>0 || ende) /* stopp ? */
X {
X if(farbe=='w')
X wei=0;
X else
X sch=0;
X
X ad_menu();
X }
X else
X ch='\0';
X }
X
X /*--- alles ausgeben ---------------------------*/
X
X move(23,79); /* Cursor weg */
X refresh(); /* ausgeben */
X }
X
X stdname[0]='\0'; /* Kein Standardname */
}
SHAR_EOF
chmod 0644 ad/training.c ||
echo 'restore of ad/training.c failed'
Wc_c="`wc -c < 'ad/training.c'`"
test 2942 -eq "$Wc_c" ||
echo 'ad/training.c: original size 2942, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= ad/tour_user.c ==============
if test -f 'ad/tour_user.c' -a X"$1" != X"-c"; then
echo 'x - skipping ad/tour_user.c (File already exists)'
rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
echo 'x - extracting ad/tour_user.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'ad/tour_user.c' &&
/****************************************************************/
/* */
/* XChess V2.7 Adapter: Curses */
/* */
/* (c) 1991 by Marc Laukien */
/* */
/* Programmteil: Spielmenue */
/* */
/****************************************************************/
X
#include <curses.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <ctype.h>
#include <time.h>
#include <sys/types.h>
X
#include "ad.h"
X
/****************************************************************/
/* Turnierspiel gegen ext. Gegner */
/****************************************************************/
X
void ad_tu_game()
X
{
X char ch='\0'; /* Eingabe */
X char s[STRLEN]; /* String */
X int ret; /* Return von domenu */
X
X /* Pfad zum Speichern */
X sprintf(stdname,"save/%s",wei==0 ? ad_id(getlogin()):
X ad_id(gegner));
X sprintf(stdname+strlen(stdname),".%s", sch==0 ?
X ad_id(getlogin()):ad_id(gegner));
X
X ad_lock();
X sprintf(s,"load %s",stdname);
X schach(s,ptr); /* Laden */
X
X if(ptr[0][0]=='?') /* existiert noch nicht ? */
X {
X sprintf(s,"save %s",stdname);
X schach(s,ptr); /* Laden */
X }
X
X ad_unlock();
X
X schach("info",ptr); /* Info holen */
X modus = atoi(ptr[9]); /* merken */
X farbe = ptr[0][0];
X level = atoi(ptr[6]);
X
X ad_menu(); /* Menue ausgeben */
X ad_brett(); /* Brett aufbauen */
X refresh(); /* ausgeben */
X
X while(1)
X {
X /*--- Spielendeueberpruefung ---------------------------*/
X if(ende) /* Spiel zu Ende ? */
X {
X switch(ende)
X {
X case W_AUFG: /* Weiss gibt auf */
X case W_MATT: /* Weiss ist matt */
X mvaddstr(2,MPOS,press_key);
X move(23,79);
X refresh();
X ad_read(0,&ch,1);/* einlesen */
X
X if((farbe=='w' && W_IS_USER())
X || (farbe=='s' && B_IS_USER()))
X { /* wer am Zug ist, traegt ein */
X ad_remove();
X ad_addscore('B');/* Score */
X }
X
X break;
X
X case S_AUFG: /* Schwarz gibt auf */
X case S_MATT: /* Schwarz ist matt */
X mvaddstr(2,MPOS,press_key);
X move(23,79);
X refresh();
X ad_read(0,&ch,1);/* einlesen */
X
X if((farbe=='w' && W_IS_USER())
X || (farbe=='s' && B_IS_USER()))
X { /* wer am Zug ist, traegt ein */
X ad_remove();
X ad_addscore('W');/* Score */
X }
X
X break;
X
X case PATT: /* Unentschieden */
X mvaddstr(2,MPOS,press_key);
X move(23,79);
X refresh();
X ad_read(0,&ch,1);/* einlesen */
X
X if((farbe=='w' && W_IS_USER())
X || (farbe=='s' && B_IS_USER()))
X { /* wer am Zug ist, traegt ein */
X ad_remove();
X ad_addscore('-');/* Score */
X }
X
X break;
X }
X
X break; /* Ende */
X }
X /*--- Externer Gegner -----------------------------------*/
X else if((farbe=='w' && W_IS_OPP())
X || (farbe=='s' && B_IS_OPP()))
X {
X int flags; /* Flags fuer ad_read() */
X int ret;
X int x;
X char str[STRLEN];
X
X sprintf(str,"%s %s",gegner,is_thinking);
X mvaddstr(2,MPOS,str); /* Status ausgeben*/
X move(23,79);
X refresh();
X ad_extzug();
X
X move(2,MPOS); /* Meldung loeschen */
X for(x=stdscr->_curx;x<79;x++) /* loeschen*/
X mvaddch(stdscr->_cury,x,(int)' ');
X
X move(23,79);
X refresh();
X
X /*--- Benutzereingabe 1 ----------------*/
X
X flags=fcntl(0,F_GETFL,0);/* flags retten */
X
X fcntl(0,F_SETFL,flags | O_NDELAY);
X ret=ad_read(0,&ch,1); /* einlesen */
X fcntl(0,F_SETFL,flags & ~O_NDELAY);
X
X if(ret==0)
X ch=' ';
X }
X
X /*--- Benutzereingabe 2 ------------------------*/
X {
X if(ch=='\0')
X ad_read(0,&ch,1);/* einlesen */
X
X if(isupper(ch)) /* gross ? */
X ch=tolower(ch);
X
X ad_flush(); /* restliche Zeichen wegwerfen */
X
X ret=ad_domenu(ch); /* auswerten */
X
X if(ret==0) /* Ende ? */
X break;
X else if(ret==2)
X {
X if((farbe=='w' && wei) || (farbe=='s' && sch))
X ad_error(not_allowed);
X else if(ad_sure('a'))
X {
X move(3,MPOS);
X
X addstr(wei==0 ? w_up:b_up);
X ende = wei==0 ? W_AUFG:S_AUFG;
X }
X }
X }
X
X ch='\0';
X
X /*--- alles ausgeben ---------------------------*/
X
X move(23,79); /* Cursor weg */
X refresh(); /* ausgeben */
X }
X
X stdname[0]='\0'; /* Kein Standardname */
}
SHAR_EOF
chmod 0644 ad/tour_user.c ||
echo 'restore of ad/tour_user.c failed'
Wc_c="`wc -c < 'ad/tour_user.c'`"
test 4036 -eq "$Wc_c" ||
echo 'ad/tour_user.c: original size 4036, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= ad/tour_comp.c ==============
if test -f 'ad/tour_comp.c' -a X"$1" != X"-c"; then
echo 'x - skipping ad/tour_comp.c (File already exists)'
rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
echo 'x - extracting ad/tour_comp.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'ad/tour_comp.c' &&
/****************************************************************/
/* */
/* XChess V2.7 Adapter: Curses */
/* */
/* (c) 1991 by Marc Laukien */
/* */
/* Programmteil: Turnierspiel gegen Computer */
/* */
/****************************************************************/
X
#include <curses.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <ctype.h>
#include <time.h>
#include <sys/types.h>
#include "ad.h"
X
/****************************************************************/
/* Turnierspiel gegen Computer */
/****************************************************************/
X
void ad_tc_game()
X
{
X char ch; /* Eingabe */
X char s[STRLEN]; /* String */
X int ret; /* return von domenu */
X
X /* Pfad zum Speichern */
X sprintf(stdname,"save/%s",wei==0 ? ad_id(getlogin()):
X ad_id(gegner));
X sprintf(stdname+strlen(stdname),".%s", sch==0 ?
X ad_id(getlogin()):ad_id(gegner));
X
X ad_lock();
X sprintf(s,"load %s",stdname);
X schach(s,ptr); /* Laden */
X ad_unlock();
X
X schach("info",ptr); /* Info holen */
X modus = atoi(ptr[9]); /* merken */
X farbe = ptr[0][0];
X level = atoi(ptr[6]);
X
X old_moves = atoi(ptr[1]); /* Anzahl der Zuege */
X
X ad_menu(); /* Menue ausgeben */
X ad_brett(); /* Brett aufbauen */
X refresh(); /* ausgeben */
X
X while(1)
X {
X /*--- Spielendeueberpruefung ---------------------------*/
X if(ende) /* Spiel zu Ende ? */
X {
X switch(ende)
X {
X case W_AUFG: /* Weiss gibt auf */
X case W_MATT: /* Weiss ist matt */
X mvaddstr(2,MPOS,press_key);
X move(23,79);
X refresh();
X ad_read(0,&ch,1);/* einlesen */
X ad_remove();
X ad_addscore('B');/* Score */
X break;
X
X case S_AUFG: /* Schwarz gibt auf */
X case S_MATT: /* Schwarz ist matt */
X mvaddstr(2,MPOS,press_key);
X move(23,79);
X refresh();
X ad_read(0,&ch,1);/* einlesen */
X ad_remove();
X ad_addscore('W');/* Score */
X break;
X
X case PATT: /* Unentschieden */
X mvaddstr(2,MPOS,press_key);
X move(23,79);
X refresh();
X ad_read(0,&ch,1);/* einlesen */
X ad_remove();
X ad_addscore('-');/* Score */
X break;
X }
X
X break; /* Ende */
X }
X /*--- Computer -----------------------------------------*/
SHAR_EOF
true || echo 'restore of ad/tour_comp.c failed'
fi
echo 'End of UnixChess part 3'
echo 'File ad/tour_comp.c is continued in part 4'
echo 4 > _shar_seq_.tmp
exit 0
--
/ | -: Marc Laukien :- |
/__ | | _ _ __
/ \ /_ / / | ml@brumuc.muc.sub.org | / \/ | / / /
/____/ / /__/ | sigma@salyko.doit.sub.org | / | /__/ /__