ċċċċċċċċċċċċċċċċċċċċċċċċċċċċċċċċċċċċċċċċċċċċċċċċċċċċċċċċċċċċPROGRAM Muehle (inpu
t,output);  (*$C-*)
(*
       Verwendet Shannon A - Strategie und den
       Alpha - Beta - Algorithmus
*)
CONST zeigen = true;
      MaxSp  = 6;        (* Maximale Spielstaerke *)

TYPE tstein   = (leer,Spieler,Rechner);
     tstr     = STRING[30];
     tzug     = ARRAY[0..3] OF integer;
     tStat    = ARRAY[Spieler..Rechner] OF RECORD
                              Modus : (Setzen,Ziehen,Springen);
                              steine,zaehler : integer;
                            END;
     tbrett = RECORD
                Anzahl : 0..1;
                k,L    : integer;
                Brett  : ARRAY[0..23] OF tstein;
                Status : tStat;
                CASE integer OF
                  0 : (Zug  : tzug);
                  1 : (von,             (* von Feldposition *)
                       zu,              (* zu  Feldposition *)
                       Schl_Nr:integer; (* Nr. des schlagbaren Steins *)
                       Muehle : boolean)
              END;

CONST steine:ARRAY[leer..Rechner] OF STRING[5]=(' ','X','0');
      geg : ARRAY[Spieler..Rechner] OF tstein=(Rechner,Spieler);

  (* Tabelle mit den Nachbarpositionen, mit denen eine
     Muehle geschlossen werden kann *)

      Muehlen_Nachb:ARRAY[0..23,0..3] OF byte=
              ((1,2,9,21),(0,2,4,7),(0,1,14,23),(4,5,10,18),
               (3,5,1,7),(3,4,13,20),(7,8,11,15),(6,8,1,4),
               (6,7,12,17),(10,11,0,21),(9,11,3,18),(9,10,6,15),
               (13,14,8,17),(5,20,12,14),(2,23,12,13),(6,11,16,17),
               (15,17,19,22),(15,16,8,12),(19,20,3,10),(18,20,16,22),
               (18,19,5,13),(22,23,0,9),(21,23,16,19),(21,22,2,14));

  (* Tabelle mit den max. vier moeglichen Nachbarpositionen
     eines Steines. 30 gibt eine nicht vorh. Position an *)

      Nachbar:ARRAY[0..23,0..3] OF byte=
              ((1,9,30,30),(2,4,0,30),(30,14,1,30),(4,10,30,30),
               (5,7,3,1),(30,13,4,30),(7,11,30,30),(8,30,6,4),
               (30,12,7,30),(10,21,30,0),(11,18,9,3),(30,15,10,6),
               (13,17,30,8),(14,20,12,5),(30,23,13,2),(16,30,30,11),
               (17,19,15,30),(30,30,16,12),(19,30,30,10),(20,22,18,16),
               (30,30,19,13),(22,30,30,9),(23,30,21,19),(30,30,22,14));

  (* Tabelle mit den 16 moeglichen Muehlen *)

        Muehlen:ARRAY[0..15,0..2] OF byte=
                ((0,1,2),(3,4,5),(6,7,8),(9,10,11),(12,13,14),
                 (15,16,17),(18,19,20),(21,22,23),(0,9,21),
                 (3,10,18),(6,11,15),(1,4,7),(16,19,22),
                 (8,12,17),(5,13,20),(2,14,23));

(* Liste mit Feldbezeichnungen der Positionen auf dem Spielbrett *)

      posit :ARRAY[0..23] OF STRING[2]=
             ('A1','D1','G1','B2','D2','F2','C3','D3',
              'E3','A4','B4','C4','E4','F4','G4','C5',
              'D5','E5','B6','D6','F6','A7','D7','G7');

VAR  Feld          : tbrett;        (* Spielbrett *)
     Spiel_ist_aus : boolean;
     Spielstaerke  : integer;
     Muehlen_menge : ARRAY[0..15] OF SET OF 0..23;
     (* Wird auf die selben Werte, wie die Konstante Muehlen gesetzt
        ==> schnellere Abfrage, ob in Muehle                         *)
    minmax     : ARRAY[1..MaxSp] OF integer;
    BestZug    : tzug;

TYPE ListenInhalt= RECORD
                      value : integer;
                      Zug   : tzug;
                    END;

FUNCTION kleiner(x,y : ListenInhalt):boolean;
  BEGIN kleiner:=x.value>y.value END; (* Absteigende Liste *)

{$I LISTE.BIB siehe Turbo-Spezial 2 }
{$I MUEHLE01.INC Initialisierung    }
{$I MUEHLE02.INC Zuggenerator       }
{$I MUEHLE03.INC Stellungsbewertung }
{$I MUEHLE04.INC Spieler&Rechnerzug }

BEGIN  (* Muehle *)
  initvars; randomize;
  REPEAT
    Initial;
    IF Antwort_Ja('Wollen Sie anfangen') THEN
      BEGIN
      SpielerZug;
      IF NOT Spiel_ist_aus THEN BEGIN
        REPEAT Feld.Zug[1]:=random(24);
        UNTIL  Feld.brett[Feld.Zug[1]]=leer;
        gotoxy(19,22); write(#7,posit[Feld.Zug[1]]);
        mache_Zug(Rechner,zeigen);
      END;
      END
    ELSE
      BEGIN
      Feld.Zug[1]:=random(24);
      gotoxy(19,22); write(#7,posit[Feld.Zug[1]]);
      mache_Zug(Rechner,zeigen);
      END;
    WHILE NOT Spiel_ist_aus DO BEGIN
      SpielerZug;
      IF NOT Spiel_ist_aus THEN RechnerZug;
     END;
   UNTIL NOT Antwort_Ja('Noch ein Spiel');
   gotoxy(1,24);
END.