ml@brumuc.muc.sub.org (Marc Laukien) (05/20/91)
Submitted-by: ml@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@brumuc.muc.sub.org | / \/ | / / /
/____/ / /__/ | sigma@salyko.doit.sub.org | / | /__/ /__