UnixChess03/10

[Marc Laukien]

Submitted-by: ml at 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 *)&copy,(char *)&score[i],sizeof(copy));
X		memcpy((char *)&score[i],(char *)&score[j],sizeof(copy));
X		memcpy((char *)&score[j],(char *)&copy,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 at brumuc.muc.sub.org   |  / \/ |   /  /  /
/____/ /   /__/   | sigma at salyko.doit.sub.org | /     |  /__/  /__