UnixChess02/10

Marc Laukien ml at brumuc.muc.sub.org
Mon May 20 10:31:04 AEST 1991


Submitted-by: ml at brumuc.muc.sub.org
Archive-name: UnixChess/part02

---- Cut Here and feed the following to sh ----
#!/bin/sh
# this is chess.02 (part 2 of UnixChess)
# do not concatenate these parts, unpack them in order with /bin/sh
# file ch/init.c continued
#
if test ! -r _shar_seq_.tmp; then
	echo 'Please unpack part 1 first!'
	exit 1
fi
(read Scheck
 if test "$Scheck" != 2; 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 ch/init.c'
else
echo 'x - continuing file ch/init.c'
sed 's/^X//' << 'SHAR_EOF' >> 'ch/init.c' &&
X			{
X				farbe |= WEI;
X				i++;
X				continue;
X			}
X
X			if(str[i]=='B')		/* Komb. fuer Schwarz ?	*/
X			{
X				farbe |= SCH;
X				i++;
X				continue;
X			}
X
X			strncpy(str2,str+i,4);		/* Zug holen	*/
X			str2[4]=0;			/* beenden	*/
X
X			open[j]=wandle_inv(str2);	/* umwandeln	*/
X			if(open[j]==(WORD)0)      	/* Fehler ? 	*/
X                		open[j]=wandle_inv("a1a1");
X						/* unmoeglicher Zug	*/
X
X			j++;
X			i += 4;			/* naechster Zug	*/
X		}
X
X		open[j]=(WORD)0;			/* beenden	*/
X
X		op[opnr]=(WORD *)malloc((unsigned)sizeof(WORD)*(j+1));
X		if(op[opnr]==(WORD *)0)		/* Fataler Fehler	*/
X			exit(1);
X
X		op_fa[opnr]=farbe;
X		memcpy((char *)op[opnr++],(char *)open,
X		(int)sizeof(WORD)*(j+1));/* kopieren	*/
X	}
X
X	fclose(fp);                		   	/* schliessen 	*/
X
X	for(i=opnr;i<MAXOP;i++)				/* loeschen	*/
X		op[i]=(WORD *)0;
}
SHAR_EOF
echo 'File ch/init.c is complete' &&
chmod 0644 ch/init.c ||
echo 'restore of ch/init.c failed'
Wc_c="`wc -c < 'ch/init.c'`"
test 4881 -eq "$Wc_c" ||
	echo 'ch/init.c: original size 4881, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= ch/list.c ==============
if test -f 'ch/list.c' -a X"$1" != X"-c"; then
	echo 'x - skipping ch/list.c (File already exists)'
	rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
echo 'x - extracting ch/list.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'ch/list.c' &&
/****************************************************************/
/*								*/
/*	XChess V2.7: Zugliste					*/
/*								*/
/*	(c) 1991 by Marc Laukien				*/
/*								*/
/****************************************************************/
X
#include "ch.h"			/* Def. des Schachspiels */
X
static void add();
static void zugliste2();
X
/****************************************************************/
/*	Zugliste erstellen					*/
/****************************************************************/
/*	Return:	Anzahl der Zuege				*/
/****************************************************************/
X
int	zugliste(dat,pos)
X
SPDAT	*dat;				/* Spieldaten	*/
BYTE	pos;				/* Position	*/
{
X	int	 nr=0;			/* Anzahl der Zuege	*/
X	register int	i,j;		/* Zaehler		*/
X
X	dat->zlist[0]=0;		/* loeschen			*/
X
X	if(pos)                      	/* nur ein Feld ?		*/
X		zugliste2(dat,pos,&nr);
X	else
X	{
X		if(dat->farbe==SCH)	/* Schwarz von unten nach oben	*/
X		for(j=0;j<8;j++)	/* alle Felder durchgehen	*/
X		for(i=0;i<8;i++)
X			if(!_istlee(dat->brett[pos=
X			(BYTE)((j+RAND)*ZLEN+i+RAND)]))
X				zugliste2(dat,pos,&nr);
X
X		if(dat->farbe==WEI)	/* Weiss von oben nach unten	*/
X		for(j=7;j>=0;j--)	/* alle Felder durchgehen	*/
X		for(i=0;i<8;i++)
X			if(!_istlee(dat->brett[pos=
X			(BYTE)((j+RAND)*ZLEN+i+RAND)]))
X				zugliste2(dat,pos,&nr);
X	}
X
X	return(nr);
}
X
static	void	zugliste2(dat,posa,nr)
X
SPDAT		*dat;			/* Spieldaten		*/
register BYTE	posa;			/* alte Position	*/
int 		*nr;            	/* Zugzaehler		*/
{
X	static short wzuege[][12] =	/* Weisse Zuege		*/
X	{
X		{0,0},
X		/* Bauerzuege		*/
X		{2,11,13,12,0},
X		/* X Bauerzuege 	*/
X		{2,11,13,12,24,0},
X		/* Springerzuege	*/
X		{0,14,25,23,10,-14,-25,-23,-10,0},
X		/* Laeuferzuege 	*/
X		{1,13,11,-13,-11,0},
X		/* Turmzuege 		*/
X		{1,1,12,-1,-12,0},
X		/* X Turmzuege	 	*/
X		{1,1,12,-1,-12,0},
X		/* Damenzuege 		*/
X		{1,1,13,12,11,-1,-13,-12,-11,0},
X		/* Koenigzuege 		*/
X		{0,1,13,12,11,-1,-13,-12,-11,0},
X		/* X Koenigzuege 	*/
X		{3,2,-2,1,13,12,11,-1,-13,-12,-11,0}
X	};
X
X	static short szuege[][12] =	/* Schwarze Zuege	*/
X	{
X		{0,0},
X		/* Bauerzuege		*/
X		{2,-11,-13,-12,0},
X		/* X Bauerzuege 	*/
X		{2,-11,-13,-12,-24,0},
X		/* Springerzuege	*/
X		{0,14,25,23,10,-14,-25,-23,-10,0},
X		/* Laeuferzuege 	*/
X		{1,13,11,-13,-11,0},
X		/* Turmzuege 		*/
X		{1,1,12,-1,-12,0},
X		/* X Turmzuege	 	*/
X		{1,1,12,-1,-12,0},
X		/* Damenzuege 		*/
X		{1,1,13,12,11,-1,-13,-12,-11,0},
X		/* Koenigzuege 		*/
X		{0,1,13,12,11,-1,-13,-12,-11,0},
X		/* X Koenigzuege 	*/
X		{3,2,-2,1,13,12,11,-1,-13,-12,-11,0}
X	};
X
X	short	(*zuege)[12];		/* effektive Zugliste	*/
X
X	/* ^ alle Zuege fuer RAND = 2	*/
X
X	register BYTE	fig;			/* Figur		*/
X	register BYTE	k;			/* Zaehler		*/
X	register BYTE	posn;			/* neue Position	*/
X	register short	zug;			/* aktueller Zug	*/
X
X	fig=dat->brett[posa];			/* Figur holen	*/
X
X	if(_farbe(fig) != dat->farbe)		/* falsche Farbe ? */
X		return;
X
X	if(dat->farbe == WEI)			/* eff. Zugl. best.*/
X		zuege=wzuege;
X	else
X		zuege=szuege;
X
X	switch(zuege[_figur(fig)][0])
X	{
X	case 0:				/* keine Wiederholung	*/
X		for(k=1;zug=zuege[_figur(fig)][k];k++)
X					/* alle Zuege durchg.	*/
X		{
X			posn=(BYTE)((short)posa+zug);
X
X			if(!(dat->farbe & _farbe(dat->brett[posn])))
X				add(dat,nr,posa,posn);
X					/* Zug anhaengen	*/
X		}
X		break;
X	case 1:				/* wiederholen		*/
X		for(k=1;zug=zuege[_figur(fig)][k];k++)
X					/* alle Zuege durchg.	*/
X		{
X			posn=(BYTE)((short)posa+zug);
X
X			while(_istlee(dat->brett[posn]))
X			{
X				add(dat,nr,posa,posn);
X					/* Zug anhaengen	*/
X				posn= (BYTE)((short)posn+zug);
X			}
X
X			if(!(dat->farbe&_farbe(dat->brett[posn])))
X				add(dat,nr,posa,posn);
X					/* Zug anhaengen	*/
X		}
X		break;
X	case 2:				/* Bauer		*/
X		for(k=1;zug=zuege[_figur(fig)][k];k++)
X					/* alle Zuege durchg.	*/
X		{
X			posn=(BYTE)((short)posa+zug);
X			if(k<=2)	/* nur schlagen		*/
X			{
X			if(_istlee(dat->brett[posn]))
X			/* Feld leer, schlagen nur e.p. mgl.	*/
X			{
X			int nb,f2,bz;
X
X			nb =  		/* Figur neben Bauer	*/
X				(short)_npos(dat->lzug)
X				- (short)posa==1 ||
X				(short)_npos(dat->lzug)
X				- (short)posa==-1
X				;
X			f2 =  		/* letzter Zug 2 Felder	*/
X				(short)_apos(dat->lzug)
X				- (short)_npos(dat->lzug)==24 ||
X				(short)_apos(dat->lzug)
X				- (short)_npos(dat->lzug)==-24
X				;
X			bz =	     /* letzter zu Bauer	*/
X				_istbau(dat->brett[_npos(dat->lzug)])
X				;
X			if(!(nb && f2 && bz))
X			/* nicht e.p., also Abbruch		*/
X				continue;
X			}
X			}
X			else		/* nicht schlagen	*/
X			if(!_istlee(dat->brett[posn]))
X				break;
X
X			if(!(dat->farbe & _farbe(dat->brett[posn])))
X				add(dat,nr,posa,posn);
X					/* Zug anhaengen	*/
X		}
X		break;
X	case 3:				/* X Koenig		*/
X		for(k=1;zug=zuege[_figur(fig)][k];k++)
X					/* alle Zuege durchg.	*/
X		{
X			posn=(BYTE)((short)posa+zug);
X
X			if(k==1)	/* Rochade rechts	*/
X			{
X				if(!_istlee(dat->brett[posa+1]))
X					continue;
X				if(!_istxtur(dat->brett[posa+3]))
X					continue;
X				if(bedrohung(dat,posa+1))
X					continue;
X				if(bedrohung(dat,posa))
X					continue;
X			}
X
X			if(k==2)	/* Rochade links	*/
X			{
X				if(!_istlee(dat->brett[posa-1]))
X					continue;
X				if(!_istlee(dat->brett[posa-3]))
X					continue;
X				if(!_istxtur(dat->brett[posa-4]))
X					continue;
X				if(bedrohung(dat,posa-1))
X					continue;
X				if(bedrohung(dat,posa))
X					continue;
X			}
X
X			if(!(dat->farbe & _farbe(dat->brett[posn])))
X				add(dat,nr,posa,posn);
X					/* Zug anhaengen	*/
X		}
X		break;
X	}
}
X
static 	void	add(dat,nr,posa,posn)
X
SPDAT	*dat;				/* Spieldaten	*/
int	*nr;				/* Anzahl der eingetragen Zuege	*/
BYTE	posa,posn;			/* alte und neue Position	*/
{
X	/* Bedrohung ueberpruefen bis minimale Rechentiefe		*/
X	if((mode&16) || /* Bedrohung immer ueberpruefen ? 		*/
X	(spdat.maxstufe-dat->maxstufe < spdat.minstufe))
X	/* ^ Falsche Berechnung beim Vorsortieren, daher dort mode|=16	*/
X	{
X		BYTE figa,fign,pos;
X		/* zieht Koenig selbst ? */
X		if(posa==dat->wkpos || posa==dat->skpos)
X			pos=posn;
X		else if(dat->farbe==WEI)
X			pos=dat->wkpos;
X		else
X			pos=dat->skpos;
X
X		figa=dat->brett[posa];		/* retten		*/
X		fign=dat->brett[posn];
X
X		dat->brett[posa]=LEE;		/* ziehen		*/
X		dat->brett[posn]=figa;
X
X		if(bedrohung(dat,pos))
X		{
X			dat->brett[posa]=figa;	/* zuruecknehmen	*/
X			dat->brett[posn]=fign;
X			return;			/* Koenig bedroht	*/
X		}
X
X		dat->brett[posa]=figa;		/* zuruecknehmen	*/
X		dat->brett[posn]=fign;
X	}
X
X	dat->zlist[(*nr)++]= posa+((WORD)posn<<8);	/* eintragen	*/
X	dat->zlist[*nr]= 0;				/* beenden	*/
}
X
/****************************************************************/
/*	Zugliste sortieren					*/
/****************************************************************/
/*	Return:	Anzahl der Zuege				*/
/****************************************************************/
X
int	sortliste(dat,stufe)
X
SPDAT	*dat;				/* Spieldaten		*/
int	stufe;				/* Vorsortierstufe	*/
{
X	int	anz;			/* Anzahl der Zuege	*/
X	int	minc,maxc;		/* Kopien der Stufen	*/
X	int	modec;			/* Kopie des Modus	*/
X	int	i,j;            	/* Zaehler		*/
X	long	bew;                   	/* Bewertung		*/
X	WORD	zug;			/* Zug			*/
X	WORD	bzug[MAXTIEFE];		/* beste Kombination	*/
X
X	minc=dat->minstufe;		/* Stufen retten	*/
X	maxc=dat->maxstufe;
X	modec=mode;
X
X	dat->minstufe=stufe;	/* Sortierstufen	*/
X	dat->maxstufe=stufe;
X	mode |= 16;		/* Koenigsbedr. immer Ueberpruefen	*/
X
X	comp_zug(dat,dat->farbe==WEI ? MATT:-MATT,bzug);
X
X	if(beende)			/* Beenden ?		*/
X		return(0);
X
X	dat->minstufe=minc;		/* wieder herstellen	*/
X	dat->maxstufe=maxc;
X	mode=modec;
X
X	for(anz=0;dat->zlist[anz]!=(WORD)0;anz++)/* Anzahl bestimmen	*/
X		;
X
X	for(i=0  ;i<anz-1;i++)			/* sortieren		*/
X	for(j=i+1;j<anz  ;j++)
X		if(dat->farbe==WEI ?
X		dat->blist[i]<dat->blist[j] : dat->blist[i]>dat->blist[j])
X		{
X			bew		=dat->blist[i];
X			dat->blist[i]	=dat->blist[j];
X			dat->blist[j]	=bew;
X			zug		=dat->zlist[i];
X			dat->zlist[i]	=dat->zlist[j];
X			dat->zlist[j]	=zug;
X		}
X
X	return(anz);
}
SHAR_EOF
chmod 0644 ch/list.c ||
echo 'restore of ch/list.c failed'
Wc_c="`wc -c < 'ch/list.c'`"
test 7783 -eq "$Wc_c" ||
	echo 'ch/list.c: original size 7783, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= ch/archiv.c ==============
if test -f 'ch/archiv.c' -a X"$1" != X"-c"; then
	echo 'x - skipping ch/archiv.c (File already exists)'
	rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
echo 'x - extracting ch/archiv.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'ch/archiv.c' &&
/****************************************************************/
/*								*/
/*	XChess V2.7: Archiv					*/
/*								*/
/*	(c) 1991 by Marc Laukien				*/
/*								*/
/****************************************************************/
X
#include <string.h>
#include <stdio.h>
#include <ctype.h>
#include "ch.h"			/* Def. des Schachspiels */
X
extern	void	exit();
extern	char	*malloc();
extern	char	*memcpy();
extern	void	free();
X
/****************************************************************/
/*	Spiel speichern						*/
/****************************************************************/
/*	Return: 1-alles ok,     0-Fehler			*/
/****************************************************************/
X
int	save_game(name)
X
char	name[];					/* Filename	*/
{
X	FILE *fp;				/* Filepointer	*/
X	char na[STRLEN];			/* effektiver Name	*/
X	int  i;
X
X	while(*name==' ')			/* Spaces loeschen	*/
X		name++;
X
X	strcpy(na,name);			/* Name aufbereiten	*/
X	strcat(na,".ch");
X
X	if((fp=fopen(na,"w"))==(FILE *)0)	/* eroeffnen	*/
X		return(0);			/* Fehler	*/
X
X	fwrite((char *)&spdat,sizeof(SPDAT),1,fp);	/* schreiben	*/
X	for(i=0;i<spdat.zuege+1;i++)
X		fwrite((char *)archiv[i],sizeof(ARCHIV),1,fp);
X	fwrite((char *)&mode,sizeof(mode),1,fp);
X	fwrite((char *)&stufe,sizeof(stufe),1,fp);
X	fwrite((char *)&varianten,sizeof(varianten),1,fp);
X	fwrite((char *)&zeit,sizeof(zeit),1,fp);
X	fwrite((char *)&varprosek,sizeof(varprosek),1,fp);
X	fwrite((char *)&compzuege,sizeof(compzuege),1,fp);
X
X	fclose(fp);
X
X	return(1);
}
X
/****************************************************************/
/*	Spiel laden						*/
/****************************************************************/
/*	Return: 1-alles ok,     0-Fehler			*/
/****************************************************************/
X
int	load_game(name)
X
char	name[];					/* Filename	*/
{
X	FILE *fp;				/* Filepointer	*/
X	char na[STRLEN];			/* effektiver Name	*/
X	int  i;
X
X	while(*name==' ')			/* Spaces loeschen	*/
X		name++;
X
X	strcpy(na,name);			/* Name aufbereiten	*/
X	strcat(na,".ch");
X
X	if((fp=fopen(na,"r"))==(FILE *)0)	/* eroeffnen	*/
X		return(0);			/* Fehler	*/
X
X	for(i=0;i<MAXSP;i++)			/* Speicher freigeben	*/
X		if(archiv[i]!=(ARCHIV *)0)
X		{
X			free(archiv[i]);
X			archiv[i]=(ARCHIV *)0;
X		}
X
X	fread((char *)&spdat,sizeof(SPDAT),1,fp);	/* lesen	*/
X	for(i=0;i<spdat.zuege+1;i++)
X	{
X		archiv[i]=(ARCHIV *)malloc((unsigned)sizeof(ARCHIV));
X		if(archiv[i]==(ARCHIV *)0)	/* Fataler Fehler	*/
X			exit(1);
X
X		fread((char *)archiv[i],sizeof(ARCHIV),1,fp);
X	}
X	fread((char *)&mode,sizeof(mode),1,fp);
X	fread((char *)&stufe,sizeof(stufe),1,fp);
X	fread((char *)&varianten,sizeof(varianten),1,fp);
X	fread((char *)&zeit,sizeof(zeit),1,fp);
X	fread((char *)&varprosek,sizeof(varprosek),1,fp);
X	fread((char *)&compzuege,sizeof(compzuege),1,fp);
X
X	fclose(fp);
X
X	return(1);
}
X
/****************************************************************/
/*	Spieldaten laden					*/
/****************************************************************/
/*	Return: 1-alles ok,     0-Fehler			*/
/****************************************************************/
X
int	load_spdat(name,dat)
X
char	name[];					/* Filename		*/
SPDAT	*dat;					/* Spieldaten		*/
{
X	FILE *fp;				/* Filepointer		*/
X	char na[STRLEN];			/* effektiver Name	*/
X
X	while(*name==' ')			/* Spaces loeschen	*/
X		name++;
X
X	strcpy(na,name);			/* Name aufbereiten	*/
X	strcat(na,".ch");
X
X	if((fp=fopen(na,"r"))==(FILE *)0)	/* eroeffnen	*/
X		return(0);			/* Fehler	*/
X
X	fread((char *)dat,sizeof(SPDAT),1,fp);	/* lesen	*/
X
X	fclose(fp);
X
X	return(1);
}
X
/****************************************************************/
/*	Spieldaten archivieren					*/
/****************************************************************/
X
void	archiviere(dat)
X
SPDAT	*dat;				/* Spieldaten		*/
{
X	int nr;				/* Zugnummer		*/
X	int i,j;
X	BYTE fig1,fig2;
X
X	nr=dat->zuege;			/* Zugnummer bestimmen	*/
X
X	if(nr>=MAXSP)			/* Speicher voll ?	*/
X		exit(1);		/* Fehler		*/
X
X	if(archiv[nr]==(ARCHIV *)0)
X	{
X		archiv[nr]=(ARCHIV *)malloc((unsigned)sizeof(ARCHIV));
X						/* Speicher holen	*/
X		if(archiv[nr]==(ARCHIV *)0)	/* Fataler Fehler	*/
X			exit(1);
X	}
X
X	memcpy((char *)archiv[nr]->brett,(char *)dat->brett,GROE);
X					/* Spielfeld kopieren		*/
X
X	archiv[nr]->farbe=dat->farbe;	/* sonstige Daten kopieren	*/
X	archiv[nr]->wkpos=dat->wkpos;
X	archiv[nr]->skpos=dat->skpos;
X	archiv[nr]->lzug=dat->lzug;
X
X	archiv[nr]->wdh= -1;		/* Keine Wiederholung		*/
X	for(i=nr-1;i>=0;i--)		/* alle durchgehen		*/
X	{
X		for(j=0;j<GROE;j++)
X		{
X			fig1=archiv[nr]->brett[j];
X			if(_istxtur(fig1))
X				fig1=TUR | _farbe(fig1);
X			if(_istxkoe(fig1))
X				fig1=KOE | _farbe(fig1);
X
X			fig2=archiv[i]->brett[j];
X			if(_istxtur(fig2))
X				fig2=TUR | _farbe(fig2);
X			if(_istxkoe(fig2))
X				fig2=KOE | _farbe(fig2);
X
X			if(fig1 != fig2)
X				break;
X		}
X
X		if(j==GROE)		/* Wiederholung gefunden 	*/
X		{
X			archiv[nr]->wdh=i;
X			break;
X		}
X	}
}
X
/****************************************************************/
/*	Spieldaten zurueckholen					*/
/****************************************************************/
/*	0: Fehler	1: ok					*/
/****************************************************************/
X
int	hole_zurueck(dat,nr)
X
SPDAT	*dat;				/* Spieldaten		*/
int 	nr;				/* Zugnummer		*/
{
X	if(nr>=MAXSP || nr<0)
X		return(0);		/* Fehler		*/
X
X	if(archiv[nr]==(ARCHIV *)0)	/* nicht belegt ?	*/
X		return(0);		/* Fehler		*/
X
X	dat->zuege=nr;			/* Zugnummer bestimmen	*/
X
X	memcpy((char *)dat->brett,(char *)archiv[nr]->brett,GROE);
X					/* Spielfeld kopieren	*/
X
X	dat->farbe=archiv[nr]->farbe;	/* sonstige Daten kop.	*/
X	dat->wkpos=archiv[nr]->wkpos;
X	dat->skpos=archiv[nr]->skpos;
X	dat->lzug =archiv[nr]->lzug;
X
X	return(1);
}
SHAR_EOF
chmod 0644 ch/archiv.c ||
echo 'restore of ch/archiv.c failed'
Wc_c="`wc -c < 'ch/archiv.c'`"
test 5629 -eq "$Wc_c" ||
	echo 'ch/archiv.c: original size 5629, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= ch/open.c ==============
if test -f 'ch/open.c' -a X"$1" != X"-c"; then
	echo 'x - skipping ch/open.c (File already exists)'
	rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
echo 'x - extracting ch/open.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'ch/open.c' &&
/****************************************************************/
/*								*/
/*	XChess V2.7: Eroeffnung und Spielphase			*/
/*								*/
/*	(c) 1991 by Marc Laukien				*/
/*								*/
/****************************************************************/
X
#include <math.h>
#include <stdio.h>
#include "ch.h"			/* Def. des Schachspiels 	*/
#include "ph.h"			/* Def. der Spielphasen		*/
X
static	WORD	op_zug();
X
/****************************************************************/
/*	effektive Stufe einstellen und Spielphase erkennen	*/
/****************************************************************/
X
void	eff_stufe(dat)
X
SPDAT 	*dat;				/* Spieldaten			*/
{
X	double	wanz,sanz;		/* Anzahl der Figurenbew.	*/
X	int	w_b,w_sl,w_td;		/* Anzahl der weissen Figuren	*/
X	int	s_b,s_sl,s_td;		/* Anzahl der schwarzen Figuren	*/
X	WORD	pos;
X	static	double bew[]=		/* Bewgungsfreiheit		*/
X					/* unter opt. Bedingungen	*/
X	{BWLEE,BWBAU,BWXBAU,BWSPR,BWLAE,BWTUR,BWXTUR,BWDAM,BWKOE,BWXKOE};
X	static	double maxanz=		/* Bewegunsfreiheit am Anfang	*/
X	2* (8*BWXBAU + 2*BWSPR + 2*BWLAE + 2*BWXTUR + BWDAM + BWXKOE);
X
X	wanz=0.; sanz=0.;		/* loeschen	*/
X	w_b=0; w_sl=0; w_td=0;
X	s_b=0; s_sl=0; s_td=0;
X
X	for(pos=RAND*ZLEN,wanz=0.,sanz=0.;pos<GROE-RAND*ZLEN;pos++)
X		if(_istwei(dat->brett[pos]))
X		{
X			wanz+=bew[_figur(dat->brett[pos])];
X			switch(_figur(dat->brett[pos]))
X			{
X			case BAU:		/* Anzahl der Figuren	*/
X			case XBAU:		/* bestimmen		*/
X				w_b++;
X				break;
X			case SPR:
X			case LAE:
X				w_sl++;
X				break;
X			case TUR:
X			case XTUR:
X			case DAM:
X				w_td++;
X				break;
X			}
X		}
X		else if(_istsch(dat->brett[pos]))
X		{
X			sanz+=bew[_figur(dat->brett[pos])];
X			switch(_figur(dat->brett[pos]))
X			{
X			case BAU:		/* Anzahl der Figuren	*/
X			case XBAU:		/* bestimmen		*/
X				s_b++;
X				break;
X			case SPR:
X			case LAE:
X				s_sl++;
X				break;
X			case TUR:
X			case XTUR:
X			case DAM:
X				s_td++;
X				break;
X			}
X		}
X
X	/*** Phasenerkennung ********************************************/
X
X	/* Bei Spielbeginn gibt es 16 Bauern und 14 Offiziere		*/
X
X	if(s_b+s_sl+s_td+w_b+w_sl+w_td == 0)	/* Remis ?		*/
X		phase=REMIS;
X	else if(!w_sl && !w_td)	/* Weisser Koenig ohne Offiziere ?	*/
X		phase=WKOEOO;
X	else if(!s_sl && !s_td)	/* Schwarzer Koenig ohne Offiziere ?	*/
X		phase=SKOEOO;
X	else if(w_b+s_b<=8 || w_sl+w_td+s_sl+s_td<=7)
X		phase=ENDSPI;		/* Endspiel			*/
X	else if(w_b+s_b<=12 || w_sl+w_td+s_sl+s_td<=12)
X		phase=MITTEL;		/* Mittelspiel			*/
X	else
X		phase=EROEFF;		/* Eroeffnung			*/
X
X	/*** Ende Phasenerkennung ***************************************/
X
X	if(mode&8 && wanz != 0 && sanz != 0)	/* Stufenanpassung ?	*/
X	{
X		dat->minstufe=		/* Rechentiefen		*/
X		(int) ((double)mintiefe[stufe]*log(maxanz)/log(wanz+sanz)+.5);
X		dat->maxstufe=
X		(int) ((double)maxtiefe[stufe]*log(maxanz)/log(wanz+sanz)+.5);
X		if(dat->maxstufe%2 != 0)
X			dat->maxstufe--;
X
X		/* Maximal doppelt	*/
X
X		if(dat->minstufe>mintiefe[stufe]*2)
X			dat->minstufe=mintiefe[stufe]*2;
X
X		if(dat->maxstufe>maxtiefe[stufe]*2)
X			dat->maxstufe=maxtiefe[stufe]*2;
X	}
X	else
X	{
X		dat->minstufe=mintiefe[stufe];
X		dat->maxstufe=maxtiefe[stufe];
X	}
}
X
/****************************************************************/
/*	Zug aus Bibliothek suchen				*/
/****************************************************************/
/*	Return:	Zug oder 0 falls keiner gefunden		*/
/****************************************************************/
X
WORD bib_zug()
X
{
X	int 	j,i,anz=0;
X	int	mgl[MAXOP];		/* Liste mit mgl. Eroeffnungen	*/
X	WORD	ko[MAXSP];		/* Kombination		*/
X
X	if(!(mode&32) || noop<=0) 	/* Bibliothek aus ? 	*/
X		return((WORD)0);
X
X	noop--;				/* Bibl.zaehler erniedrigen	*/
X
X	if(mode&64)		/* bestimmte Eroeffnung nehmen	*/
X	{
X		i=testopnr;
X
X		for(j=0;j<spdat.zuege && op[i][j]!=(WORD)0;j++)
X			if(archiv[j+1]->lzug!=op[i][j])
X				break;	/* passt nicht		*/
X
X		if(j==spdat.zuege && op[i][j]!=(WORD)0)
X		{			/* passt		*/
X			mgl[anz++]=i;
X			noop=OPTRYS;	/* Bibl. wieder oeffnen	*/
X		}
X	}
X	else
X		for(i=0;i<opnr;i++)		/* Eroeffnungen testen	*/
X		{
X			for(j=0;j<spdat.zuege;j++) /* Komb. erstellen	*/
X				ko[j]=archiv[j+1]->lzug;
X
X			ko[j]=(WORD)0;		/* beenden	*/
X
X
X			if(op_zug(ko,&op[i][0]) != (WORD)0)
X			{			/* Zug gefunden		*/
X				if(op_fa[i] & spdat.farbe)
X					mgl[anz++]=i;
X				/* Eroeffnung fuer die richtige Farbe	*/
X				
X				noop=OPTRYS;	/* Bibl. wieder oeffnen	*/
X				/* ^ Wichtig ! Die Bib. muss auch er-	*/
X				/* oeffnet werden, wenn die Farbe nicht	*/
X				/* stimmt, da sonst beim naechsten Zug	*/
X				/* fuer die andere Farbe nicht mehr 	*/
X				/* nachgesehen wird.			*/
X			}
X		}
X
X	if(anz == 0)
X		return((WORD)0);	/* nix gefunden		*/
X
X	i=rand();   	   		/* zufaellig beginnen	*/
X	while(i>=anz)
X		i -= anz;
X
#ifdef	ANALYSE		/* einfache Analyse ein ?	*/
X	if(mode & 128)
X	{
X		WORD komb[2];				/* Kombination	*/
X		char str[STRLEN];
X
X		komb[0]=op[mgl[i]][spdat.zuege];	/* eintragen	*/
X		komb[1]=(WORD)0;			/* beenden	*/
X
X		strcpy(str,kombination(&spdat,komb));
X		strcat(str," (Library)");
X		ANALYSE(str);
X	}
#endif
X
X	return(op[mgl[i]][spdat.zuege]);	/* gefunden	*/
}
X
static	WORD	op_zug(ko,er)
X
WORD	*ko,*er;	/* Kombination, Eroeffnung	*/
{
X	int	len,i,j;
X	WORD	ek[MAXSP];	/* Kopie der Eroeffnung	*/
X
X	len=spdat.zuege;	/* Laenge der Kombination feststellen */
X
X	for(i=0;i<len+1;i++)	/* er in ek kopieren	*/
X	{
X		if(er[i]==(WORD)0)	 /* Kombination laenger als 	*/
X			return((WORD)0); /* Eroeffnung			*/
X
X		ek[i]=er[i];
X	}
X
X	ek[len]=(WORD)0;	/* beenden	*/
X
X	for(i=0;i<len;i += 2)	/* Weisse Zuege durchsuchen	*/
X	{
X		for(j=0;j<len;j += 2)
X			if(ek[j]==ko[i])	/* Zug gefunden	*/
X			{
X				ek[j]=(WORD)0;	/* streichen	*/
X				break;
X			}
X
X		if(j>=len)	/* Zug nicht gefunden	*/
X			return((WORD)0);
X	}
X
X	for(i=1;i<len;i += 2)	/* Schwarze Zuege durchsuchen	*/
X	{
X		for(j=1;j<len;j += 2)
X			if(ek[j]==ko[i])	/* Zug gefunden	*/
X			{
X				ek[j]=(WORD)0;	/* streichen	*/
X				break;
X			}
X
X		if(j>=len)	/* Zug nicht gefunden	*/
X			return((WORD)0);
X	}
X
X	return(er[len]);	/* Zug als Ergebnis	*/
}
X
/****************************************************************/
/*	Eroeffungen aus Bibliothek testen			*/
/****************************************************************/
/*	Return:	1: alles ok	0: Fehler			*/
/****************************************************************/
X
int 	bib_test()
X
{
X	FILE	*fp2,*fp=(FILE *)0;	/* Filepointer		*/
X	int	zug;			/* Zugnummer		*/
X	int	mode2;
X	char	str[200*5];
X	int	i;
X
X	mode2 = mode;			/* retten		*/
X
X	mode &= !(1+128);		/* Analyse aus		*/
X	mode |=	32+64;			/* Eroeffnungstest ein	*/
X
X	init(&spdat,1);			/* Initialisierungen	*/
X
X	testopnr=0;			/* Eroeffungsnummer	*/
X
X	if((fp2=fopen("chess.op","r"))==(FILE *)0)	/* oeffnen	*/
X		exit(1);                                /* Fehler 	*/
X
X	while(testopnr<opnr)
X	{
X		while(!feof(fp2))	/* Eroeffnung suchen	*/
X	       	{
X			fgets(str,999,fp2);      /* einlesen 	*/
X
X        	        i=0;
X			while(str[i]!='#' && str[i]!='\n' && str[i]!=0)
X				i++;
X
X			str[i]=0;               /* beenden 	*/
X
X			if(strlen(str))	/* Keine Leerzeile  ?	*/
X				break;
X		}
X
X		zug=0;			/* erster Zug		*/
X
fprintf(stderr,"%d/%d\n",testopnr+1,opnr);
X
X		while((spdat.bzug=bib_zug())!=(WORD)0)	/* Zug in Bib. ?*/
X		{
X			if(zug_test(&spdat,spdat.bzug))	/* Testen	*/
X			{
X				ziehe(&spdat,spdat.bzug);/* ziehen	*/
X				archiviere(&spdat);	/* speichern	*/
X				zug++;
X			}
X			else				/* Fehler !	*/
X			{
X				/* Fehlerfile oeffnen	*/
X				if(fp==(FILE *)0)
X					fp=fopen("error.op","w");
X
X				fprintf(fp,"%d%c%d/%d:\n%s\n",
X				testopnr+1,TAB,zug/2+1,zug%2+1,str);
X				break;
X			}
X		}
X	
X		testopnr++;		/* naechste Eroeffung	*/
X
X		init(&spdat,1);		/* Initialisierungen	*/
X	}
X
X	mode=mode2;		/* wieder herstellen	*/
X	
X	fclose(fp2);
X
X	if(fp!=(FILE *)0)	/* Fehler gefunden ?	*/
X	{
X		fclose(fp);	/* schliessen 	*/
X		return(0);	/* Fehler !	*/
X	}
X	else
X		return(1);	/* alles ok	*/
}
SHAR_EOF
chmod 0644 ch/open.c ||
echo 'restore of ch/open.c failed'
Wc_c="`wc -c < 'ch/open.c'`"
test 7762 -eq "$Wc_c" ||
	echo 'ch/open.c: original size 7762, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= ch/stat.c ==============
if test -f 'ch/stat.c' -a X"$1" != X"-c"; then
	echo 'x - skipping ch/stat.c (File already exists)'
	rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
echo 'x - extracting ch/stat.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'ch/stat.c' &&
/****************************************************************/
/*								*/
/*	XChess V2.7: Status					*/
/*								*/
/*	(c) 1991 by Marc Laukien				*/
/*								*/
/****************************************************************/
X
#include <string.h>
#include <stdio.h>
#include <ctype.h>
#include "ch.h"			/* Def. des Schachspiels */
#include "ph.h"			/* Spielphase		 */
X
/****************************************************************/
/*	Status bestimmen					*/
/****************************************************************/
X
void	status_aus(dat,ret)
X
SPDAT 	*dat;				/* Spieldaten		*/
char	*ret[];				/* Antworten		*/
{
X	int	anz;			/* Zaehler		*/
X	char	bed;			/* Bedrohung		*/
X	int 	i;
X
X	eff_stufe(dat);			/* Phasenerkennung	*/
X
X	/*--- Test auf 3-fache Wiederholung --------------------*/
X
X	for(i=dat->zuege;i>=0;i--)	/* Wdh. finden		*/
X		if(archiv[i]->wdh != -1)
X		if(archiv[archiv[i]->wdh]->wdh!= -1)
X			break;		/* gefunden		*/
X
X	if(i > -1)			/* 3-fache Wiederholung	*/
X	{
X		sprintf(ret[zaehler++],"3");
X		return;
X	}
X
X	/*--- Test, ob Koenige fehlen ---------------------------*/
X
X	if(dat->wkpos==(BYTE)0 && dat->skpos==(BYTE)0)
X	{
X		strcpy(ret[zaehler++],"r");	/* Remis 		*/
X		return;
X	}
X	else if(dat->wkpos==(BYTE)0)
X	{
X		strcpy(ret[zaehler++],"mw");	/* Weiss ist matt	*/
X		return;
X	}
X	else if(dat->skpos==(BYTE)0)
X	{
X		strcpy(ret[zaehler++],"ms");	/* Schwarz ist matt	*/
X		return;
X	}
X
X	/*--- Spielphase auf Remis untersuchen -----------------*/
X
X	if(phase==REMIS)
X	{
X		strcpy(ret[zaehler++],"r");
X		return;
X	}
X
X	/*--- Test auf Matt und Patt und Schach ----------------*/
X
X	anz=zugliste(dat,(BYTE)0);	/* Zuege bestimmen	*/
X
X	if(dat->farbe==WEI && bedrohung(dat,dat->wkpos))
X		bed='w';
X	else if(dat->farbe==SCH && bedrohung(dat,dat->skpos))
X		bed='s';
X	else
X		bed='\0';
X
X	if(!anz)			/* Matt oder Patt ?	*/
X	{
X		if(bed=='\0')		/* Patt ?		*/
X			strcpy(ret[zaehler++],"p");
X
X		else			/* Matt 		*/
X			sprintf(ret[zaehler++],"m%c",bed);
X	}
X	else				/* nur Schach oder nix	*/
X		sprintf(ret[zaehler++],"%c",bed);
}
SHAR_EOF
chmod 0644 ch/stat.c ||
echo 'restore of ch/stat.c failed'
Wc_c="`wc -c < 'ch/stat.c'`"
test 2027 -eq "$Wc_c" ||
	echo 'ch/stat.c: original size 2027, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= ad/main.c ==============
if test ! -d 'ad'; then
    echo 'x - creating directory ad'
    mkdir 'ad'
fi
if test -f 'ad/main.c' -a X"$1" != X"-c"; then
	echo 'x - skipping ad/main.c (File already exists)'
	rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
echo 'x - extracting ad/main.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'ad/main.c' &&
/****************************************************************/
/*								*/
/*	XChess V2.7 Adapter: Curses				*/
/*								*/
/*	(c) 1991 by Marc Laukien				*/
/*								*/
/*	Programmteil:	Hauptprogramm				*/
/*								*/
/****************************************************************/
X
#include <curses.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include "ad.h"
X
char	*pname;			/* Prgname: argv[0] 		*/
char	*cwd;			/* Working Directory 		*/
char	stdname[STRLEN]="";	/* Standardname fuers Speichern	*/
char	def[STRLEN]=LANG;	/* Definitionen			*/
int	lock=0;			/* Falls 1: Lock erworben	*/
int	curses=0;		/* Falls 1: Curses an		*/
int	inter;			/* Falls 1: Es war ein Interrupt*/
int	break_pid= -1;		/* Prozessid des Unterbrechers	*/
WINDOW	*win=(WINDOW *)0;	/* Subwindow			*/
WINDOW	*setupwin=(WINDOW *)0;	/* Setup-Subwindow		*/
X
char	farbe;			/* w=weiss,s=schwarz		*/
int	wei;			/* 0=Spieler			*/
int	sch;			/* 1=Computer oder Gegener	*/
char	gegner[STRLEN];		/* Spielgegner (leer:Computer)	*/
int	level;			/* Spielstufe			*/
int	ende;			/* 1:Matt oder Patt		*/
int	modus;			/* eingestellter Modus		*/
char	ant[PTR][81];		/* Antworten			*/
char	*ptr[PTR];		/* Pointer auf Antw.		*/
X
int	old_moves;	/* Anzahl der Zuege bei Spielbeginn	*/
/* ^ Wird benoetigt, um festzustellen, ob beim Verlassen	*/
/* eines Turnierspieles gegen den Computer (regulaer oder	*/
/* durch Interrupt) Speichern noetig ist			*/
X
extern	void	exit();
extern	int	umask();
X
/****************************************************************/
/*	Hauptprogramm						*/
/****************************************************************/
X
int	main(argc,argv,envp)
X
int 	argc;
char 	*argv[];
char 	*envp[];
{
X	extern 	char 	*optarg;
X	extern 	int  	optind,opterr;
X	char		c;
X	char		str[STRLEN];
X	int		testop=0;	/* Falls 1: Eroeffungen testen	*/
X	int		expire=0;	/* Falls 1: Expire		*/
X	int		i;
X
X	umask(077);			/* Filecreationmask	*/
X
X	pname=argv[0];			/* Programmname 	*/
X
X	for(i=0;i<PTR;i++)		/* Pointer setzen 	*/
X		ptr[i]= &ant[i][0];
X
X	cwd=getcwd((char *)0,STRLEN);	/* Directory retten 	*/
X
X	if(chdir(WORKDIR)== -1)		/* Directory aendern	*/
X	{
X		fprintf(stderr,
X		"%s: unknown path %s\n",pname,WORKDIR);
X		exit(1);
X	}
X
X	/* Optionen einlesen *******************************************/
X
X	opterr=1;
X	while((c=(char)getopt(argc,argv,"etd:"))!=EOF)
X		switch(c)
X		{
X		case 'd':		/* andere Sprache 		*/
X			strcpy(def,optarg);
X			break;
X
X		case 't':		/* Eroeffungsbibliothek testen	*/
X			testop=1;
X			break;
X
X		case 'e':		/* Expire	*/
X			expire=1;
X			break;
X
X		default:
X		case '?':		/* Fehler 	*/
X			opterr++;
X			break;
X		}
X
X	if(opterr>1)			/* falsche Optionen */
X	{
X		fprintf(stderr,
X		"usage: %s [-t] [-e] [-d file]\n",pname);
X		ad_deinit();
X		exit(1);
X	}
X	
X	/* Ende Optionen einlesen **************************************/
X
X	if(testop)			/* Eroeffungen testen	*/
X	{
X		schach("testbib",ptr);
X
X		if(ptr[0][0]=='?')		/* Fehler ?		*/
X		{
X			fprintf(stderr,
X	"%s: error in chess.op (see error.op for more information)\n",pname);
X			ad_deinit();
X			exit(1);
X		}
X		else
X			fprintf(stderr,"%s: no errors in chess.op\n",pname);
X
X	}
X	else if(expire)			/* Expire ?	*/
X	{
X		ad_expire();
X	}
X	else	/* Normales Spiel	*/
X	{
X		ad_init();			/* initialsieren	*/
X
X		ad_admin();			/* Administrationsmenue	*/
X
X		ad_deinit();			/* deinitialsieren	*/
X	}
X
X	return(0);			/* alles ok		*/
}
SHAR_EOF
chmod 0644 ad/main.c ||
echo 'restore of ad/main.c failed'
Wc_c="`wc -c < 'ad/main.c'`"
test 3355 -eq "$Wc_c" ||
	echo 'ad/main.c: original size 3355, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= ad/init.c ==============
if test -f 'ad/init.c' -a X"$1" != X"-c"; then
	echo 'x - skipping ad/init.c (File already exists)'
	rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
echo 'x - extracting ad/init.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'ad/init.c' &&
/****************************************************************/
/*								*/
/*	XChess V2.7 Adapter: Curses				*/
/*								*/
/*	(c) 1991 by Marc Laukien				*/
/*								*/
/*	Programmteil:	Initialisierungen			*/
/*								*/
/****************************************************************/
X
#include <curses.h>
#include <stdio.h>
#include <signal.h>
#include <string.h>
#include "ad.h"
X
extern	void	exit();
X
static	struct	termio	term,oterm;	/* Terminaldaten */
X
/****************************************************************/
/*	Initialisierungen					*/
/****************************************************************/
X
void	ad_init()
{
X	int 	i,ch;
X	int 	pfd[2];
X
X	lex();				/* Strings einlesen 	*/
X
X	if(startcmd[0]!=(char)0)
X		system(startcmd);	/* Startkommando ausf.	*/
X
X	/**** Unterbrecher starten			****/
X
X	if(pipe(pfd)== -1)	/* Pipe erzeugen	*/
X	{			/* Fehler ?	*/
X		ad_error("");
X		ad_deinit();
X		exit(1);
X	}
X
X	if((break_pid=fork())== -1)	/* Fehler ?	*/
X	{
X		ad_error("");
X		ad_deinit();
X		exit(1);
X	}
X
X	if(break_pid==0)	/* Sohn ?	*/
X	{
X		close(1);	/* Standardausgabe schliessen	*/
X		dup(pfd[1]);	/* neue Standardausgabe		*/
X		close(pfd[0]);	/* Pipes schliessen		*/
X		close(pfd[1]);
X		execlp("./chbrk","./chbrk",(char *)0);	/* starten	*/
X		ad_error("");
X		ad_deinit();
X		exit(1);
X	}
X	else			/* Vater ?	*/
X	{
X		close(0);	/* Standardeingabe schliessen	*/
X		dup(pfd[0]);	/* neue Standardeingabe		*/
X		close(pfd[0]);	/* Pipes schliessen		*/
X		close(pfd[1]);
X	}
X
X	/**** Ende Unterbrecher starten			****/
X
X	initscr();			/* Curses ein		*/
X	curses=1;
X
X	if(ioctl(1,TCGETA,&oterm)== -1)	/* termio retten */
X	{
X		ad_error("");
X		ad_deinit();
X		exit(1);
X	}
X
X	if(ioctl(1,TCGETA,&term)== -1)	/* termio holen */
X	{
X		ad_error("");
X		ad_deinit();
X		exit(1);
X	}
X
X	term.c_cc[VEOF]=1;		/* veraendern */
X	term.c_cc[VEOL]=1;
X	term.c_lflag &= ~(ICANON | ECHO);
X
X	if(ioctl(1,TCSETA,&term))
X	{
X		ad_error("");
X		ad_deinit();
X		exit(1);
X	}
X
X	ad_startint();		/* Interrupt starten	*/
}
X
/****************************************************************/
/*	Deinitialisierungen					*/
/****************************************************************/
X
void	ad_deinit()
{
X	if(break_pid!= -1)		/* Unterbrecher laeuft ?*/
X		kill(break_pid,SIGTERM);/* beenden		*/
X
X	if(lock==1)			/* Lock erworben ?	*/
X		ad_unlock();		/* freigeben		*/
X
X	if(curses==1)			/* Curses an ?		*/
X	{
X		char	s[STRLEN];
X
X		ioctl(1,TCSETA,&oterm);	/* termio herstellen 	*/
X		endwin();		/* Curses aus		*/
X
X		if(stdname[0]!='\0' && !ende && UEBUNG())
X		{
X			ad_lock();
X			sprintf(s,"save %s",stdname);
X			schach(s,ptr);		/* Speichern		*/
X			ad_unlock();
X		}
X
X		if(stdname[0]!='\0' && !ende && TURNCOM())
X		{
X			schach("info",ptr);	/* Info holen	*/
X
X			if(atoi(ptr[1]) != old_moves)
X			{		/* veraendert ?		*/
X				ad_lock();
X				sprintf(s,"save %s",stdname);
X				schach(s,ptr);	/* Speichern	*/
X				ad_unlock();
X			}
X		}
X	}
X
X	fflush(stdout);			/* Buffer leeren	*/
X	fflush(stdin);
X
X	chdir(cwd);			/* Directory herstellen	*/
}
X
/****************************************************************/
/*	Neustart						*/
/****************************************************************/
X
void	ad_new()
{
X	static	int	first=1;
X
X	if(first)	/* Laden der Bib. einmal anzeigen	*/
X	{
X		ad_msg(load_lib);
X		first=0;
X	}
X
X	schach("init",ptr);		/* Initialsieren 	*/
X	if(ptr[0][0]=='?')		/* Fehler ?		*/
X	{
X		ad_error("");
X		ad_deinit();
X		exit(1);
X	}
X	schach("stufe 2",ptr);		/* Stufe einstellen	*/
X
X	if(UEBUNG())			/* Uebungsspiel ?	*/
X	{
X		char	str[STRLEN];
X
X		sprintf(str,"stufe %d",atoi(tr_lv)-1);
X		schach(str,ptr);	/* Level einstellen	*/
X
X		wei=0;			/* 0=Spieler		*/
X		sch=1;			/* 1=Computer		*/
X	}
X
X	if(TURNIER())			/* Turnierspiel		*/
X	{
X		char	str[STRLEN];
X
X		sprintf(str,"stufe %d",atoi(to_lv)-1);
X		schach(str,ptr);	/* Level einstellen	*/
X	}
X
X	ende=0;				/* 1:Matt oder Patt	*/
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
X	ad_menu();		/* Menue ausgeben	*/
X
X	move(23,79);		/* Cursor weg		*/
}
X
/****************************************************************/
/*	Partie loeschen						*/
/****************************************************************/
X
void	ad_remove()
{
X	char	str[STRLEN*2];
X
X	if(stdname[0]=='\0')	/* Kein Name definiert ?	*/
X		return;
X
X	sprintf(str,"%s/%s.ch",WORKDIR,stdname);
X	unlink(str);
X
X	sprintf(str,"%s/%s.lock",WORKDIR,stdname);
X	unlink(str);
}
SHAR_EOF
chmod 0644 ad/init.c ||
echo 'restore of ad/init.c failed'
Wc_c="`wc -c < 'ad/init.c'`"
test 4435 -eq "$Wc_c" ||
	echo 'ad/init.c: original size 4435, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= ad/utility.c ==============
if test -f 'ad/utility.c' -a X"$1" != X"-c"; then
	echo 'x - skipping ad/utility.c (File already exists)'
	rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
echo 'x - extracting ad/utility.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'ad/utility.c' &&
/****************************************************************/
/*								*/
/*	XChess V2.7 Adapter: Curses				*/
/*								*/
/*	(c) 1991 by Marc Laukien				*/
/*								*/
/*	Programmteil:	Utilities				*/
/*								*/
/****************************************************************/
X
#include <curses.h>
#include <stdio.h>
#include <ctype.h>
#include <signal.h>
#include <fcntl.h>
#include <pwd.h>
#include "ad.h"
X
static char ad_convert();	/* Vorwaerstdeklaration		*/
X
/****************************************************************/
/*	Brett aufbauen						*/
/****************************************************************/
X
void	ad_brett()
X
{
X	int	x=0,y=0;		/* Koordinaten	*/
X	int	ch;
X	int	i;
X	static	char fig[]="KDTTLLSSBBBBBBBB";	/* Figuren	*/
X	int	wfig[16];			/* schw. Fig.	*/
X	int	sfig[16];			/* wei. Fig	*/
X
X	schach("brett",ptr);		/* ausfuehren	*/
X
X	for(i=0;i<16;i++)		/* loeschen	*/
X	{
X		wfig[i]=(int)ad_convert(tolower(fig[i]))|A_BOLD;
X		sfig[i]=(int)ad_convert(fig[i])|A_REVERSE;
X	}
X
X	for(y=0;y<8;y++)		/* Koordinaten durchgehen	*/
X	for(x=0;x<8;x++)
X	{
X		ch=(int)ant[y][x*2];
X
X		if(islower(ch))			/* weiss ?	*/
X		{
X			for(i=0;i<16;i++)	/* durchsuchen	*/
X				if((char)wfig[i]==ad_convert((char)ch))
X				{		/* eintragen	*/
X					wfig[i]=(int)ad_convert('.');
X					break;
X				}
X
X			ch = (int)ad_convert((char)ch)|A_BOLD;
X						/* hell		*/
X		}
X		else if(isupper(ch))		/* schwarz ?	*/
X		{
X			for(i=0;i<16;i++)	/* durchsuchen	*/
X				if((char)sfig[i]==ad_convert((char)ch))
X				{		/* eintragen	*/
X					sfig[i]=(int)ad_convert('.');
X					break;
X				}
X
X			ch = (int)ad_convert((char)ch)|A_REVERSE;
X						/* invers	*/
X		}
X		else if(ch==(int)'.')		/* leer ?	*/
X		{
X			ch = (int)ad_convert((char)ch);
X			if(!(x%2 ^ y%2))	/* schwarzes Feld ?	*/
X				ch |= A_REVERSE|A_BOLD;
X			else
X				ch |= A_BOLD;
X		}
X
X		mvaddch(y*3+1,x*5+3,ch);	/* eintragen	*/
X	}
X
X	move(20,8*5+3);		/* geschl. schw. Fig ausgeben	*/
X	for(i=0;i<16;i++)
X	{
X		addch(sfig[i]);
X		addch((int)' ');
X	}
X	move(21,8*5+3);		/* geschl. weisse Fig ausgeben	*/
X	for(i=0;i<16;i++)
X	{
X		addch(wfig[i]);
X		addch((int)' ');
X	}
X
X	ad_status();		/* Status ausgeben	*/
}
X
static char ad_convert(ch)	/* Figur umwandeln	*/
X
char ch;
{
X	char ret;
X
X	ret=ch;			/* Returnwert	*/
X
X	switch(ch)
X	{
X	case 'b':		/* Bauer	*/
X		ret=figtab[0];
X		break;
X	case 's':		/* Springer	*/
X		ret=figtab[1];
X		break;
X	case 'l':		/* Laeufer	*/
X		ret=figtab[2];
X		break;
X	case 't':		/* Turm		*/
X		ret=figtab[3];
X		break;
X	case 'd':		/* Dame		*/
X		ret=figtab[4];
X		break;
X	case 'k':		/* Koenig	*/
X		ret=figtab[5];
X		break;
X	case 'B':		/* Bauer	*/
X		ret=figtab[6];
X		break;
X	case 'S':		/* Springer	*/
X		ret=figtab[7];
X		break;
X	case 'L':		/* Laeufer	*/
X		ret=figtab[8];
X		break;
X	case 'T':		/* Turm		*/
X		ret=figtab[9];
X		break;
X	case 'D':		/* Dame		*/
X		ret=figtab[10];
X		break;
X	case 'K':		/* Koenig	*/
X		ret=figtab[11];
X		break;
X	case '.':		/* Koenig	*/
X		ret=figtab[12];
X		break;
X	}
X
X	return(ret);
}
X
/****************************************************************/
/*	Status ausgeben						*/
/****************************************************************/
X
void	ad_status()
X
{
X	int  i;
X
X	attrset(0);		/* Alle Attribute aus	*/
X
X	schach("status",ptr);	/* ausfuehren		*/
X	ende=0;
X	move(3,MPOS);
X
X	if(!strcmp(ptr[0],"p"))	/* Patt			*/
X	{
X		addstr(patt);
X		ende=PATT;
X	}
X	else if(!strcmp(ptr[0],"r"))	/* Remis		*/
X	{
X		addstr(patt);
X		ende=PATT;
X	}
X	else if(!strcmp(ptr[0],"mw"))	/* Matt Weiss		*/
X	{
X		addstr(w_mate);
X		ende=W_MATT;
X	}
X	else if(!strcmp(ptr[0],"ms"))	/* Matt Schwarz		*/
X	{
X		addstr(b_mate);
X		ende=S_MATT;
X	}
X	else if(!strcmp(ptr[0],"w"))	/* Schach Weiss		*/
X		addstr(w_chess);
X	else if(!strcmp(ptr[0],"s"))	/* Schach Schwarz	*/
X		addstr(b_chess);
X	else if(!strcmp(ptr[0],"3"))	/* Dreifache Wiederholung	*/
X	{
X		addstr(remis_3);
X		ende=1;
X	}
X
X	for(i=stdscr->_curx;i<79;i++)	/* Rest der Zeile loeschen	*/
X		mvaddch(stdscr->_cury,i,(int)' ');
X
X	move(23,79);
}
X
/****************************************************************/
/*	Eigenes read()						*/
/****************************************************************/
X
int	ad_read(fd,buf,num)
X
int	fd;	/* Filedeskriptor	*/
char	*buf;	/* Buffer		*/
int	num;	/* Anzahl der Zeichen	*/
X
{
X	int ret;	/* Returnwert	*/
X
X	do
X	{
X		inter=0;		/* Interrupt ruecksetzen	*/
X		ret=read(fd,buf,num);	/* Zeichen lesen 	  	*/
X	} while(inter==1);
X
X	return(ret);
}
X
/****************************************************************/
/*	Eingabebuffer leeren					*/
/****************************************************************/
X
void	ad_flush()
{
X	int 	flags;				/* Flags fuer read() 	*/
X	char	c;
X
X	flags=fcntl(0,F_GETFL,0);		/* flags retten 	*/
X
X	/* Buffer leeren	*/
X	fcntl(0,F_SETFL,flags | O_NDELAY);	/* blockierung aus 	*/
X	while(read(0,&c,1));			/* Zeichen lesen   	*/
X	fcntl(0,F_SETFL,flags & ~O_NDELAY);	/* blockierung ein 	*/
}
SHAR_EOF
chmod 0644 ad/utility.c ||
echo 'restore of ad/utility.c failed'
Wc_c="`wc -c < 'ad/utility.c'`"
test 4819 -eq "$Wc_c" ||
	echo 'ad/utility.c: original size 4819, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= ad/monitor.c ==============
if test -f 'ad/monitor.c' -a X"$1" != X"-c"; then
	echo 'x - skipping ad/monitor.c (File already exists)'
	rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
echo 'x - extracting ad/monitor.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'ad/monitor.c' &&
/****************************************************************/
/*								*/
/*	XChess V2.7 Adapter: Curses				*/
/*								*/
/*	(c) 1991 by Marc Laukien				*/
/*								*/
/*	Programmteil:	Analyse					*/
/*								*/
/****************************************************************/
X
#include <curses.h>
#include "ad.h"
X
/****************************************************************/
/*	Analyse ausgeben					*/
/****************************************************************/
X
void ad_analyse(str)
X
char *str;
{
X	int	i;
X
X	move(23,0);			/* an die Ausgabestelle gehen	*/
X	attrset(A_REVERSE);
X	addstr(str);			/* ausgeben	*/
X	attrset(0);
X	for(i=0+strlen(str);i<79;i++)	/* loeschen	*/
X		addch((int)' '|A_REVERSE);
X	refresh();			/* ausgeben	*/
}
SHAR_EOF
chmod 0644 ad/monitor.c ||
echo 'restore of ad/monitor.c failed'
Wc_c="`wc -c < 'ad/monitor.c'`"
test 752 -eq "$Wc_c" ||
	echo 'ad/monitor.c: original size 752, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= ad/window.c ==============
if test -f 'ad/window.c' -a X"$1" != X"-c"; then
	echo 'x - skipping ad/window.c (File already exists)'
	rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
echo 'x - extracting ad/window.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'ad/window.c' &&
/****************************************************************/
/*								*/
/*	XChess V2.7 Adapter: Curses				*/
/*								*/
/*	(c) 1991 by Marc Laukien				*/
/*								*/
/*	Programmteil:	Windows					*/
/*								*/
/****************************************************************/
X
#include <curses.h>
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include "ad.h"
X
/****************************************************************/
/*	info ausgeben						*/
/****************************************************************/
X
void	ad_info()
X
{
X	char	str[STRLEN];		/* String		*/
X	int 	l=2;			/* Zeile		*/
X	int 	nr=0;			/* Ausgabe Nummer	*/
X	char	c;
X
X	schach("info",ptr);		/* ausfuehren		*/
X
X	win=newwin(15,35,4,3);		/* neues Window		*/
X	box(win,0,0);			/* mit Rahmen		*/
X
X	farbe=ptr[nr][0];		/* FARBE		*/
X	sprintf(str,"%s%s",info[0],ptr[nr++][0]=='w'?white:black);
X	wmove(win,l++,2);		/* positionieren	*/
X	waddstr(win,str);		/* ausgeben		*/
X
X	sprintf(str,"%s%s",info[1],ptr[nr++]);	/* ZUEGE	*/
X	wmove(win,l++,2);		/* positionieren	*/
X	waddstr(win,str);		/* ausgeben		*/
X
X	sprintf(str,"%s%s",info[2],ptr[nr++]);	/* WERTUNG	*/
X	wmove(win,l++,2);		/* positionieren	*/
X	waddstr(win,str);		/* ausgeben		*/
X
X	sprintf(str,"%s%s",info[3],ptr[nr++]);	/* VARIANTEN	*/
X	wmove(win,l++,2);		/* positionieren	*/
X	waddstr(win,str);		/* ausgeben		*/
X
X	sprintf(str,"%s%s",info[4],ptr[nr++]);	/* VAR/SEK	*/
X	wmove(win,l++,2);		/* positionieren	*/
X	waddstr(win,str);		/* ausgeben		*/
X
X	sprintf(str,"%s%s",info[5],ptr[nr++]);	/* DURCHSCHNITT	*/
X	wmove(win,l++,2);		/* positionieren	*/
X	waddstr(win,str);		/* ausgeben		*/
X
X	sprintf(str,"%s%d",info[6],atoi(ptr[nr++])+1);	/* STUFE*/
X	wmove(win,l++,2);		/* positionieren	*/
X	waddstr(win,str);		/* ausgeben		*/
X
X	sprintf(str,"%s%s",info[7],ptr[nr++]);	/* TIEFE MIN	*/
X	wmove(win,l++,2);		/* positionieren	*/
X	waddstr(win,str);		/* ausgeben		*/
X
X	sprintf(str,"%s%s",info[8],ptr[nr++]);	/* TIEFE MAX	*/
X	wmove(win,l++,2);		/* positionieren	*/
X	waddstr(win,str);		/* ausgeben		*/
X
X	nr++;			/* MODE wird nicht benoetigt	*/
X
X	sprintf(str,"%s%s",info[9],ptr[nr++]);	/* LETZTER ZUG	*/
X	wmove(win,l++,2);		/* positionieren	*/
X	waddstr(win,str);		/* ausgeben		*/
X
X	wmove(win,l++,2);		/* positionieren	*/
X	waddstr(win,press_key);		/* TASTE		*/
X	wrefresh(win);			/* ausgeben		*/
X	move(23,79);
X	refresh();
X
X	ad_read(0,&c,1);		/* auf Taste warten	*/
X
X	delwin(win);			/* Fenster aus		*/
X	win=(WINDOW *)0;
X	touchwin(stdscr);
}
X
/****************************************************************/
/*	Filenamen/Gegnernamen einlesen				*/
/****************************************************************/
X
char 	*ad_name(mode)
X
char	mode;	/* f = Filename		g = Gegner	*/
{
X	char 	str[STRLEN];		/* String		*/
X	static	char s[STRLEN];		/* Return-String	*/
X	char 	c;			/* Zeichen		*/
X	int 	i=0;
X
X	if(mode!='g' && mode !='f')	/* Fehler ?		*/
X		return("");
X
X	win=newwin(3,60,10,10);		/* neues Window		*/
X	box(win,0,0);			/* mit Rahmen		*/
X	wmove(win,1,1);
X	waddstr(win,mode=='f' ? enter:opponent);
X	wmove(win,1,1+strlen(mode=='f' ? enter:opponent));
X
X	str[i]=0;			/* loeschen		*/
X
X        do
X	{
X		wrefresh(win);		/* ausgeben		*/
X		ad_read(0,&c,1);	/* Zeichen einlesen	*/
X
X		if(c=='\b' && i>0)	/* Backspace	*/
X		{
X			waddstr(win,"\b \b");
X			str[--i]=0;
X		}
X
X		if(c==127)		/* Delete	*/
X			while(i>0)
X			{
X				waddstr(win,"\b \b");
X				str[--i]=0;
X			}
X
X		if(isprint(c) &&
X		(mode == 'f' ? i<5 : i<57-strlen(opponent))
X		&& c!='/' && c!='.' && c!=' ')
X		{
X			waddch(win,(int)c);	/* ausgeben	*/
X			str[i]=c;
X			str[++i]=0;
X		}
X	}
X	while(c!='\n' && c!=(char)13);
X	
X	wrefresh(win);			/* ausgeben		*/
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(mode=='f')
X	{
X		sprintf(s,"training/%s.",ad_id(getlogin()));
X					/* Pfad dazu		*/
X		strcat(s,str);
X	}
X	else
X		strcpy(s,str);		/* ohne Pfad		*/
X
X	return(s);
}
X
/****************************************************************/
/*	Fehlermeldung						*/
/****************************************************************/
X
void	ad_error(s)
X
char 	*s;
{
X	char str[STRLEN];		/* String		*/
X	char c;
X
X	if(curses)			/* Curses an ?		*/
X	{
X		if(s[0]==0)		/* externer Fehler ?	*/
X			sprintf(str,"%s%s",error,sys_errlist[errno]);
X		else			/* interner Fehler ?	*/
X			sprintf(str,"%s%s",error,s);
X
X		win=newwin(3,60,10,10);	/* neues Window		*/
X		box(win,0,0);		/* mit Rahmen		*/
X		wmove(win,1,1);
X		waddstr(win,str);
X		wmove(win,1,59-strlen(press_key));
X		waddstr(win,press_key);
X
X		refresh();
X		wrefresh(win);		/* ausgeben		*/
X		move(23,79);
X		refresh();
X
X		ad_read(0,&c,1);		/* auf Taste warten	*/
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	else
X		fprintf(stderr,"%s: %s\n",pname,sys_errlist[errno]);
}
X
/****************************************************************/
/*	Meldung							*/
/****************************************************************/
X
void	ad_msg(s)
X
char 	*s;
{
X	int 	i;
X
X	win=newwin(2,80,22,0);	/* neues Window		*/
X	wmove(win,0,0);
X	for(i=0;i<80;i++)	/* Linie		*/
X		waddch(win,(int)'-');
X
X	wmove(win,1,39-strlen(s)/2);
X	waddstr(win,s);
X
X	refresh();
X	wrefresh(win);		/* ausgeben		*/
X	move(23,79);
X	refresh();
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
/****************************************************************/
/*	Sicherheitsabfrage					*/
/****************************************************************/
/*	Return: 0-nein    1-ja					*/
/****************************************************************/
X
int	ad_sure(mode)
X
char	mode;	/* s = Sicher ?		a = Aufgeben ?		*/
{
X	char 	c;			/* Zeichen		*/
X	char	*str;
X
X	if(mode=='s')
X		str=sure;
X	else if(mode=='a')
X		str=give_up;
X	else
X		return(0);
X
X	win=newwin(3,60,10,10);		/* neues Window		*/
X	box(win,0,0);			/* mit Rahmen		*/
X	wmove(win,1,1+(58-strlen(str+2))/2);
X	waddstr(win,str+2);
X
X	wrefresh(win);			/* ausgeben		*/
X	move(23,79);
X	refresh();
X
X	do
X	{
X		ad_read(0,&c,1);	/* auf Taste warten	*/
X
X		if(isupper(c))		/* klein machen		*/
X			c=tolower(c);
X
X		if(c!=str[0] && c!=str[1])
SHAR_EOF
true || echo 'restore of ad/window.c failed'
fi
echo 'End of UnixChess part 2'
echo 'File ad/window.c is continued in part 3'
echo 3 > _shar_seq_.tmp
exit 0
-- 
   /              |    -: Marc Laukien :-     |
  /__             |                           |   _  _           __
 /   \  /_  /  /  |   ml at brumuc.muc.sub.org   |  / \/ |   /  /  /
/____/ /   /__/   | sigma at salyko.doit.sub.org | /     |  /__/  /__



More information about the Alt.sources mailing list