
Program schachspiel;
{ Autor:   Jürgen Schlottke, Schönaich-C.-Str. 46, D-W 2200 Elmshorn
           Tel. 04121/63109
  Zweck  : Demonstration der Schachprogrammierung unter Turbo-Pascal
  Datum  : irgendwann 1991, als PD freigegeben am 18.01.93
  Version: ohne Versionsnummer
}

{$R-,S-,D-,B-,A+}  {Compileroptionen für schnellste Programmausführung}

uses crt,dos;

const
quitting:boolean=false;      {Soll das Spiel beendet werden}
halbzugzahl:integer=0;           {Anzahl der gemachten Züge}
rechentiefe:byte=2;      {Rechentiefe des Computers in Halbzügen}
Maxtiefe:byte=4;           {Maximale Rechentiefe bei Schlagzügen}
ohneWert=0;                        {Wert eines leeren Felds}
bauernwert=2;                       {Wert eines Bauernfelds}
laeuferwert=6;                                        {etc.}
springerwert=7;
Turmwert=10;
Koenigswert=126;
Damenwert=19;
ausserhalb=127;     {Wert eines Felds außerhalb des Brettes}

         {Bewegungsrichtungen der Figuren auf dem Spielfeld}
bauer:array[1..4]of shortint=(1,2,-9,11);
springer:array[1..8]of shortint=(12,21,19,8,-12,-21,-19,-8);
laeufer:array[1..4]of shortint=(11,-11,9,-9);
turm:array[1..4]of shortint=(-1,1,-10,10);
koenig:ARRAY [1..8] OF shortint=(-1,1,-10,10,11,-11,9,-9);

TYPE
  brt=RECORD
    brett:array[-10..109] of shortint;           {Spielfeld}
                     { 11 - Springer[6] .. 88 + Springer[2]}
    epfeld:array[-1..1] of shortint;     {En-Passant-Felder}
    zuglistevon:array[1..100]of byte;         {Ausgangsfeld}
    zuglistenach:array[1..100]of byte;             {Endfeld}
    zugwert:array[1..100] of integer;            {Bewertung}
    anz:INTEGER;                {Anzahl der gefundenen Züge}
    material:INTEGER;                       {Materialbilanz}
    farbe:shortINT; {Farbe des am Zug befindlichen Spielers}
  END;

VAR
  spielbrett,               {Auf diesem Brett wird gespielt}
  grundbrett:brt;               {Ein Brett in Grundstellung}
  wert,eom:integer;
  varianten:LONGINT;   {Anzahl der berechneten Zugvarianten}
  mgzugvon:array[1..100] of byte;   {Die bestmöglichen Züge}
  mgzugnach:array[1..100] of byte;
  mgzugwert:array[1..100] of integer;
  historyvon:array[1..700] of byte; {Speichert 700 Halbzüge}
  historynach:array[1..700] of byte;
  a:CHAR;
  start,ende:real;           {Für Berechnung der Rechenzeit}
  id: ByTE ABSOLUTE $F000:$FFFE;

procedure vorspann;
var c:char;
begin
clrscr;
writeln('SCHACH - PD-Software by Jürgen Schlottke');
writeln;
writeln('Diese Programmversion beherrscht folgende Funktionen:');
writeln;
writeln('      -  Nur gültige Züge werden zugelassen');
writeln('      -  Umwandlung durchgebrachter Bauern in Damen');
writeln('      -  lange und kurze Rochade sind möglich (E1G1, E1C1, E8G8, E8C8)');
writeln('      -  Prüfung auf Schach für den Spieler sowie Matt&Patt für den Computer');
writeln('      -  Computer spielt wahlweise schwarz oder weiß');
writeln('      -  Farbwechsel auch während des Spiels möglich');
writeln('      -  Zurücknehmen von beliebig vielen Zügen möglich');
writeln('      -  Schlagen en passant');
writeln;
writeln('Das Programm sowie der TP-Quellcode sind als "Public Domain" freigegeben.');
writeln('EXE-Programm und PAS-Quellcode sollen nur zusammen weitergegeben werden.');
writeln('Das Programm darf in der vorliegenden Form frei verwendet werden, Garantien');
writeln('und Supportleistungen sind ausgeschlossen.');
writeln;
writeln('Jürgen Schlottke');
writeln('Schönaich-Carolath-Str. 46');
writeln('D-W 2200 Elmshorn');
writeln('Tel. 04121/63109');
writeln;
write('Taste ...');
while not keypressed do;
while keypressed do c:=readkey;
end;


procedure starttime;
{ Zweck: Globale Variable "start" auf aktuelle Zeit setzen }
var starthou,startmin,startsec,starthun:word;
Label PExit;
begin
  gettime(starthou,startmin,startsec,starthun);
  start:=starthou*3600+startmin*60+startsec+starthun/100;
end;

procedure endtime;
{ Zweck: Ausgabe der verbrauchten Rechenzeit}
var endhou,endmin,endsec,endhun:word;
    zeit:real;
begin
  gettime(endhou,endmin,endsec,endhun);
  ende:=endhou*3600+endmin*60+endsec+endhun/100;
  zeit:=ende-start;
  clrscr; {Ausgabefenster löschen}
  writeln('Zeit: ',zeit:1:2,' sec');
  if zeit<>0 then zeit:=varianten/zeit else zeit:=9999999;
                 {Falls weniger als 1/18 sec gebraucht wird}
  writeln('Varianten: ',varianten);
  writeln('Tempo: ',zeit:1:2,' V/sec');
  writeln;
end;


function stellungswert
           (VAR spielbrett:brt;farbe:shortINT):INTEGER;
{Zweck: Bewertung der aktuellen Brettstellung}
BEGIN
  stellungswert:=spielbrett.material*farbe;
END; {stellungswert}


PROCEDURE grundstellung(VAR spielbrett:brt);
{Zweck: Grundaufstellung der Figuren}
VAR i,j:integer;
BEGIN
  WITH grundbrett DO
  begin
    FOR i:=-9 TO 110 DO brett[i]:=ausserhalb;
    FOR i:=1 TO 8 DO
      FOR j:=1 TO 8 DO brett[i*10+j]:=ohneWert;

    FOR i:=1 TO 8 DO brett[i*10+2]:=bauernwert;
    FOR i:=1 TO 8 DO brett[i*10+7]:=-bauernwert;
    brett[21]:=springerwert;
    brett[71]:=springerwert;
    brett[31]:=laeuferwert;
    brett[61]:=laeuferwert;
    brett[11]:=Turmwert;
    brett[81]:=Turmwert;
    brett[51]:=Koenigswert;
    brett[41]:=Damenwert;
    brett[28]:=-springerwert;
    brett[78]:=-springerwert;
    brett[38]:=-laeuferwert;
    brett[68]:=-laeuferwert;
    brett[18]:=-Turmwert;
    brett[88]:=-Turmwert;
    brett[58]:=-Koenigswert;
    brett[48]:=-Damenwert;


    material:=0;
    farbe:=1;
  END;
  spielbrett:=grundbrett;
END; {grundstellung}


PROCEDURE brettdarstellung(VAR brett:brt);
{Zweck: Darstellung des Bretts auf dem Monitor}
VAR Y,X:word;
    LEER,FARBE:INTEGER;

  PROCEDURE wstring(X,Y:INTEGER);
  var  z:INTEGER;
BEGIN
    if y=177 then textcolor(15) else textcolor(7);
    FOR z:=1 TO X DO write (chr(Y));
END; { wstring}

  PROCEDURE wlstring(X,Y:INTEGER);
  var  z:INTEGER;
  Label PExit;
BEGIN
    textcolor(7);textbackground(0);
    FOR z:=1 TO X DO write (chr(Y));
END; { wlstring}


  PROCEDURE loc(z:INTEGER);
  Label PExit;
BEGIN
  CASE z OF
  1: Gotoxy(x*7-6,25-Y*3);
  2:Gotoxy(x*7-6,26-Y*3);
  3:Gotoxy(x*7-6,27-Y*3);
  END;
  ;PExit:
end; {loc}

  PROCEDURE leeresfeld(LEER:INTEGER);
  var i:byte;
BEGIN
  for i:=1 to 3 do
  begin
    loc(i);
    wlstring(7,LEER);
  end;
END; { leeresfeld}

  PROCEDURE bauer(LEER,FARBE:INTEGER);
BEGIN
  loc(1);
  wlstring(7,LEER);
  loc(2);
  wlstring(3,LEER);
  Wstring(1,farbe);
  wlstring(3,LEER);
  loc(3);
  wlstring(7,LEER)
END; {bauer}

PROCEDURE dame(LEER,FARBE:INTEGER);
BEGIN
loc(1);
wlstring(2,LEER);wstring(4,FARBE);wlstring(1,LEER);
loc(2);
wlstring(2,LEER);Write('DAME');wlstring(1,LEER);
loc(3);
wlstring(2,LEER);wstring(4,FARBE);wlstring(1,LEER);
END; {dame}

PROCEDURE koenig(LEER,FARBE:INTEGER);
BEGIN
loc(1);
wlstring(1,LEER);wstring(5,FARBE);wlstring(1,LEER);
loc(2);
wlstring(1,LEER);Write('KÖNIG');wlstring(1,LEER);
loc(3);
wlstring(1,LEER);wstring(5,FARBE);wlstring(1,LEER);
END; { koenig}


PROCEDURE springer(LEER,FARBE:INTEGER);
BEGIN
loc(1);
wlstring(2,LEER);wstring(3,FARBE);wlstring(2,LEER);
loc(2);
wlstring(3,leer);wstring(2,farbe);wlstring(2,leer);
loc(3);
wlstring(3,LEER);wstring(2,FARBE);wlstring(2,LEER);
END; { springer}


PROCEDURE laeufer(LEER,FARBE:INTEGER);
BEGIN
loc(1);
wlstring(3,LEER);wstring(2,FARBE);wlstring(2,LEER);
loc(2);
{wlstring(1,LEER);Write('LÄUFER');wlstring(0,LEER);}
wlstring(3,LEER);wstring(2,FARBE);wlstring(2,LEER);
loc(3);
wlstring(2,LEER);wstring(4,FARBE);wlstring(1,LEER);
END; { laeufer}


PROCEDURE turm(LEER,FARBE:INTEGER);
BEGIN
loc(1);
wlstring(2,LEER);wstring(1,FARBE);wlstring(2,LEER);
                 wstring(1,FARBE);wlstring(1,LEER);
loc(2);
wlstring(2,LEER);Write('TURM');wlstring(1,LEER);
loc(3);
wlstring(2,LEER);wstring(4,FARBE);wlstring(1,LEER);
END; {turm}

PROCEDURE figurausgeben(VAR Y,X:word);
var figurfarbe:integer;
BEGIN
  IF (X+Y) MOD 2=0 THEN LEER:=32 ELSE LEER:=219;
  IF spielbrett.brett[X*10+Y]<0 THEN figurFARBE:=176
    ELSE figurFARBE:=177;

  CASE ABS(spielbrett.brett[X*10+Y]) OF
    ohneWert    :   leeresfeld(LEER);
    bauernwert  : bauer(LEER,figurFARBE);
    springerwert:   springer(LEER,figurFARBE);
    laeuferwert :   laeufer(LEER,figurFARBE);
    turmwert    : turm(LEER,figurFARBE);
    koenigswert : koenig(LEER,figurFARBE);
    Damenwert   :   dame(LEER,figurFARBE);
  END;
END; { figurausgeben}

BEGIN   {brettdarstellung}
    window(1,1,80,25);
    FOR Y:=1 TO 8 DO
      FOR X:=1 TO 8 DO figurausgeben(Y,X);
    gotoxy(1,25);
    if brett.farbe=1 then write('Weiß')
       else write('Schwarz');
    write(' ist am Zug.');clreol;
END; {brettdarstellung}


PROCEDURE setzen(VAR spielbrett:brt; von,nach:byte);
{Zweck: Einen Zug auf dem Spielbrett ausführen}
BEGIN
  WITH spielbrett DO
  begin
     {Wenn Bauer zwei Felder zieht,
                                dann En-Passant ermöglichen}
     if (abs(nach-von)=2) and
        (abs(brett[von])=bauernwert) then
       epfeld[farbe]:=von+bauer[1]*farbe
       else epfeld[farbe]:=0;

     {Wenn En-Passant-Zug, dann erst den Bauern
      des Gegners ein Feld zurücksetzen}
     if (nach=epfeld[-farbe]) and
        (brett[von]=bauernwert*farbe) then
       begin
         epfeld[farbe]:=0;
         setzen(spielbrett,von,(nach div 10)*10+von mod 10);
         farbe:=-farbe;
         von:=(nach div 10)*10+von mod 10;
       end;


    if (von in [51,58]) and (nach in [71,31,78,38]) and
       (abs(brett[von])=koenigswert) then
    begin                             {Beginnen mit Rochade}
      brett[nach]:=brett[von];                {König setzen}
      brett[von]:=0;
      if nach div 10=7 then                  {kurze Rochade}
      begin
        von:=(von mod 10)+80;nach:=von-20;
                                        {Turm geht 2 Felder}
      end
      else                                   {lange Rochade}
      begin
        von:=(von mod 10)+10;nach:=von+30;
                                        {Turm geht 3 Felder}
      end;
      brett[nach]:=brett[von];
      brett[von]:=0;
    end
    else                             {ein ganz normaler Zug}
    begin
      material:=material-brett[nach];
      brett[nach]:=brett[von];
      brett[von]:=0;
      if (nach mod 10=1) or (nach mod 10=8) then
        if abs(brett[nach])=bauernwert then
        begin                              {damenumwandlung}
          brett[nach]:=damenwert*farbe;
          material:=material+(damenwert-bauernwert)*farbe;
        end;
    end;
    farbe:=-farbe;
  END;   { with }
END;   { setzen }


PROCEDURE eintragen(var spielbrett:brt;von,nach:shortint);
{Zweck: Einen gültigen Zug in die Zugliste eintragen}
BEGIN  {eintragen}
  WITH spielbrett DO
  begin
    if abs(material)>83 then Exit;
                 {Weiterspielen hat keinen Zweck mehr, Ende}
    inc(anz);
    zuglistevon[anz]:=von;
    zuglistenach[anz]:=nach;
  end;
END; {eintragen}


PROCEDURE zuggenerator_ohne(VAR spielbrett:brt);
{Zweck: Alle möglichen Zügen ermitteln (ohne Rochade)}
VAR von,nach:shortint;
    i,j,k,l:byte;

BEGIN  {zuggenerator_ohne}
WITH spielbrett DO
begin
  anz:=0;                       {Anzahl der gefundenen Züge}
  for j:=1 to 8 do            {Alle Spielfelder durchlaufen}
  for k:=1 to 8 do
    begin
      von:=j*10+k;                              {von=11..88}
      if brett[von]<>ohnewert then
      begin
        case brett[von]*farbe of
        bauernwert:
        begin
          nach:=von+bauer[1]*farbe;
          IF brett[nach]=ohnewert THEN
          begin
             eintragen(spielbrett,von,nach);
             if (farbe=1) and (k=2) or
                (farbe=-1) and (k=7) then
             begin
               nach:=von+bauer[2]*farbe;
               IF (brett[nach]=ohnewert) THEN
               begin
                 eintragen(spielbrett,von,nach);
               end;
             end;
          END;
         for i:=3 to 4 do
         begin
           nach:=von+bauer[i]*farbe ;
           if (-brett[nach]*farbe in
                [bauernwert..koenigswert]) or
                (nach=epfeld[-farbe]) then
              eintragen(spielbrett,von,nach);
         end;
        END;
        springerwert:
        begin
          FOR i:=1 TO 8 DO
          begin
           nach:=von+springer[i];
           if -brett[nach]*farbe in
                       [ohnewert..koenigswert] then
              eintragen(spielbrett,von,nach);
          END;
        end;
        laeuferwert:
        begin
         FOR i:=1 TO 4 DO
         begin
            nach:=von;
            REPEAT
              inc(nach,laeufer[i]);
           if -brett[nach]*farbe in
                       [ohnewert..koenigswert] then
              eintragen(spielbrett,von,nach);
            UNTIL brett[nach] <>ohnewert;
          END;
        end;
        Turmwert:
        begin
            FOR i:=1 TO 4 DO
            begin
               nach:=von;
               REPEAT
                 inc(nach,turm[i]);
                 if -brett[nach]*farbe in
                             [ohnewert..koenigswert] then
                   eintragen(spielbrett,von,nach);
               UNTIL brett[nach] <>0;
             END;
         end;
         Koenigswert:
         begin
          FOR i:=1 TO 8 DO
          begin
             nach:=von+koenig[i];
             if -brett[nach]*farbe in
                         [ohneWert..Koenigswert] then
             begin   {Testen wo der gegnerische König steht}
               l:=0;
               repeat
                 inc(l);
               until
                 (-brett[nach+koenig[l]]*farbe=koenigswert)
                 or (l=8);
               if l=8 then eintragen(spielbrett,von,nach);
             end;
          END;
         end;
         Damenwert:
         begin
          FOR i:=1 TO 8 DO
          begin
              nach:=von;
              REPEAT
                inc(nach,koenig[i]);
                 if -brett[nach]*farbe in[0..126] then
                   eintragen(spielbrett,von,nach);
              UNTIL brett[nach] <>0;
          END;
         end;
         END; {case}
       end; {if}
    END; {FOR}
END; {WITH}
END; { zuggenerator_ohne}


function schach(VAR spielbrett:brt):BOOLEAN;
{Zweck: Testen, ob der König im Schach steht}
VAR i:byte;

BEGIN  {schach}      {Aufruf nachdem gesetzt wurde}
  with spielbrett do
  begin
    farbe:=-farbe;
    zuggenerator_ohne(spielbrett);
    farbe:=-farbe;
    schach:=false;
    for i:=1 to anz do
    begin
      if abs(brett[zuglistenach[i]])=koenigswert then
        schach:=true;    {wenn der Gegner den König erreicht}
    end; {for}
  end;  {with}
END;  {schach}


PROCEDURE zuggenerator(VAR spielbrett:brt);
{Zweck: Ermitteln aller Züge incl. Rochade}
procedure Rochade_testen
       (vonkoenig:byte;step:shortint;turmfeld:byte);
var brett1:brt;i:shortint;
begin
  with spielbrett do
  begin
    if brett[turmfeld]*farbe<>turmwert then Exit;
    i:=vonkoenig+step;
    repeat
      if brett[i]<>0 then Exit;
      inc(i,step);
    until i=turmfeld;
    brett1:=spielbrett;
    if not schach(brett1) then
      eintragen(spielbrett,vonkoenig,vonkoenig+2*step);
          {steht der König auch nicht im Schach?}
  end;
end;

BEGIN {zuggenerator}
zuggenerator_ohne(spielbrett); {erst normale Züge ermitteln}
WITH spielbrett DO                  {danach die Rochadezüge}
begin
  if brett[51]*farbe=koenigswert then
  begin
    Rochade_testen(51,10,81);
    Rochade_testen(51,-10,11);
  end
  else
  if brett[58]*farbe=koenigswert then
  begin
    Rochade_testen(58,10,88);
    Rochade_testen(58,-10,18);
  end;
end;
end; {zuggenerator}

function maxwertung
   (VAR spielbrett:brt;farbe,tiefe,alpha:INTEGER):INTEGER;
{Zweck: Rekursive Bewertung eines Spielbretts}
VAR minmax,wertung,zugnr:INTEGER;
    brett1:brt;
    beta:INTEGER;
    alphabetaabbruch:BOOLEAN;

BEGIN  {maxwertung}
  zuggenerator(spielbrett);        {alle Züge incl. Rochade}
  zugnr:=0;
  beta:=-32000*spielbrett.farbe*farbe;
  alphabetaabbruch:=FALSE;
  WHILE (zugnr<spielbrett.anz) AND
                     NOT (alphabetaabbruch) DO
  begin
    inc(zugnr);
    brett1:=spielbrett;
    with spielbrett do
    setzen(brett1,zuglistevon[zugnr],zuglistenach[zugnr]);

    if ((tiefe>=rechentiefe) and
       (spielbrett.brett[spielbrett.zuglistenach[zugnr]]=0))
       or  (tiefe=maxtiefe) then
    begin
        wertung:=stellungswert(brett1,farbe);
        inc(varianten);
    end
    else
    begin
          wertung:=maxwertung(brett1,farbe,tiefe+1,beta);
    end;
      IF spielbrett.farbe=farbe THEN
      begin
        IF wertung>beta THEN beta:=wertung;
        IF beta >alpha THEN alphabetaabbruch:=TRUE;
      end ELSE
      begin
        IF wertung<beta THEN beta:=wertung;
        IF beta<alpha THEN alphabetaabbruch:=TRUE;
      END;

    spielbrett.zugwert[zugnr]:=wertung;
  END;
  maxwertung:=beta;
END; { maxwertung}


function spielereingabe:boolean;
{Zweck: Feststellen, was der Spieler will}
var i:byte;brett1:brt;
var eingabe:string[4];
label start;
VAR   zug,code:INTEGER;
      von,nach:byte;
BEGIN
window(60,1,80,25);
start:
code:=1;
while code<>0 do
begin
  gotoxy(1,21);write('9999 = ENDE');
  gotoxy(1,22);write('9900 = Computer zieht');
  gotoxy(1,23);write('9001 = Zurücknehmen');
  Gotoxy(1,24);
  Write('Ihr Zug: ');
  clreol;
  Readln(eingabe); { eingabe:='9900';}
  spielereingabe:=true;
  if eingabe[1]='9' then
  begin
    spielereingabe:=false;
    if eingabe='9999' then
    begin
      quitting:=true;
    end;
    if eingabe='9900' then
       spielereingabe:=true;
    if eingabe='9001' then
    begin
      clrscr;
      grundstellung(spielbrett);
      if halbzugzahl>2 then dec(halbzugzahl,2) else
         halbzugzahl:=0;
      for i:=1 to halbzugzahl do
        setzen(spielbrett,historyvon[i],historynach[i]);
      brettdarstellung(spielbrett);
    end;
    Exit;
  end;
  eingabe[1]:=upcase(eingabe[1]);
  eingabe[3]:=upcase(eingabe[3]);
  if (eingabe[1] in ['A'..'H']) and
     (eingabe[3] in ['A'..'H']) then
  begin
    eingabe[1]:=chr(ord(eingabe[1])-16);
    eingabe[3]:=chr(ord(eingabe[3])-16);
  end;
  val(eingabe,zug,code);
end;
von:=zug DIV 100;
nach:=zug MOD 100;
zuggenerator(spielbrett); {Alle Züge incl. Rochade}
code:=0;
with spielbrett do
begin
for i:=1 to anz do
  if zug=zuglistevon[i]*100+zuglistenach[i] then code:=1;
end;{with}

if (code=0) then goto start;
brett1:=spielbrett;
setzen(brett1,von,nach);
brett1.farbe:=-brett1.farbe;
if schach(brett1) then goto start;
setzen(spielbrett,von,nach);
brettdarstellung(spielbrett);
inc(halbzugzahl);
historyvon[halbzugzahl]:=von;
historynach[halbzugzahl]:=nach;
END; {spielereingabe}


PROCEDURE computerzug;
var i,j:byte;
{Zweck: Den besten Computerzug berechnen und ausführen}

procedure zugausgeben(von,nach:byte);
var zugstr:string[5];
    zug:integer;

begin
zug:=von*100+nach;
str(zug,zugstr);
zugstr[1]:=chr(ord(zugstr[1])+16);
zugstr[3]:=chr(ord(zugstr[3])+16);
write(zugstr,'   ');
end;

function feld_ist_in_grundstellung
         (var spielbrett:brt;feldnr:byte):boolean;
begin
  if spielbrett.brett[feldnr]=grundbrett.brett[feldnr] then
    feld_ist_in_grundstellung:=true
    else feld_ist_in_grundstellung:=false;
end;


function besterzug:byte;
var brett1:brt;
   i,j:byte;
   bestcounter:integer;
begin
  WITH spielbrett DO
  begin
    eom:=0;
    for i:=1 to anz do
    begin
      IF zugwert[i]=wert THEN
      begin
        inc(eom);
        mgzugvon[eom]:=zuglistevon[i];
        mgzugnach[eom]:=zuglistenach[i];
        mgzugwert[eom]:=0;
      END;
    end;
  end;
  bestcounter:=0;
  besterzug:=1;
  for i:=1 to eom do
  begin
    brett1:=spielbrett;
    mgzugwert[i]:=0;

    with brett1 do
    begin
      if feld_ist_in_grundstellung(brett1,mgzugvon[i]) then
      begin
        inc(mgzugwert[i],5);
        if abs(brett[mgzugvon[i]])=bauernwert then
           inc(mgzugwert[i],2);
      end;
      if (abs(brett[mgzugvon[i]])=koenigswert) then
         dec(mgzugwert[i],10);
      if (halbzugzahl<32) and
         (abs(brett[mgzugvon[i]]) in
              [bauernwert,laeuferwert,springerwert]) then
              inc(mgzugwert[i],20);

      if (mgzugvon[i] div 10=1) or (mgzugvon[i] div 10=8) or
         (mgzugvon[i] mod 10=1) or (mgzugvon[i] mod 10=8)
         then inc(mgzugwert[i],2);

      if (mgzugnach[i] div 10=1) or (mgzugnach[i] div 10=8)
         or (mgzugnach[i] mod 10=1)
         or (mgzugnach[i] mod 10=8)
         then dec(mgzugwert[i],2);
    end; {with}
    brett1:=spielbrett;
    setzen(brett1,mgzugvon[i],mgzugnach[i]);
    if feld_ist_in_grundstellung(brett1,mgzugnach[i]) then
      dec(mgzugwert[i],10);

    brett1.farbe:=-brett1.farbe;
    zuggenerator_ohne(brett1);
    with brett1 do
    begin
      for j:=1 to anz do
      begin
        inc(mgzugwert[i]);
        if zuglistenach[j]<>0 then
        begin
          inc(mgzugwert[i]);
        end;
      end;
    end;
    brett1.farbe:=-brett1.farbe;
    zuggenerator_ohne(brett1);
    with brett1 do
    begin
      for j:=1 to anz do
      begin
        dec(mgzugwert[i]);
        if zuglistenach[j]<>0 then
        begin
          dec(mgzugwert[i]);
        end;
      end;
    end;

      if mgzugwert[i]>=bestcounter then
      begin
        bestcounter:=mgzugwert[i];
        besterzug:=i;
      end;

  end; {for}
end;

var schon_im_schach:boolean;
BEGIN  {Computerzug}
window(60,1,80,25);
clrscr;
write('Bitte warten');
varianten:=0;
starttime;
if (id=252) or (id=248) then
begin
  rechentiefe:=3;      {Rechentiefe des Computers in Halbzügen}
  Maxtiefe:=5;         {Maximale Rechentiefe bei Schlagzügen}
end;
wert:=maxwertung(spielbrett,spielbrett.farbe,1,32000);
endtime;
writeln('Berechnete Züge:');
i:=besterzug;
for j:=1 to eom do
  if j<33 then zugausgeben(mgzugvon[j],mgzugnach[j])
  else if j=33 then write('etc.');

inc(halbzugzahl);
historyvon[halbzugzahl]:=mgzugvon[i];
historynach[halbzugzahl]:=mgzugnach[i];

schon_im_schach:=schach(spielbrett);
setzen(spielbrett,mgzugvon[i],mgzugnach[i]);
spielbrett.farbe:=-spielbrett.farbe;
if schach(spielbrett) then
begin
  writeln;
  if schon_im_schach then
    writeln('Ich bin SCHACHMATT')
  else
    writeln('Es ist ein PATT');
  halt;
end;
Gotoxy(1,18);
Write('Mein Zug: ');
zugausgeben(mgzugvon[i],mgzugnach[i]);
writeln;
{writeln('  Materialwertung: ',wert,'     ');}
spielbrett.farbe:=-spielbrett.farbe;
if schach(spielbrett) then
  writeln('SCHACH!'#7) else writeln;
brettdarstellung(spielbrett);write(#7);
END; {computerzug}


BEGIN  {BEGINN DES HAUPTPROGRAMMS: SCHACHSPIEL }
vorspann;
clrscr;
grundstellung(spielbrett);
brettdarstellung(spielbrett);
REPEAT
  if spielereingabe then computerzug;
UNTIL quitting;

END. { ENDE DES HAUPTPROGRAMMS: SCHACHSPIEL }

