MODULE skat;

   FROM InOut IMPORT WriteString, WriteLn, WriteInt;
   FROM RandomGenerator IMPORT Random;

   CONST 
      a      = 1;
      b      = 32;
      anzahl = 5;
      spiele = 10000;

   TYPE 
      Farbe     = (Kreuz, Pik, Herz, Karo);
      Wert      = (As, Koenig, Dame, Bube, Zehn, Neun, Acht, Sieben);
      Skatkarte = 
         RECORD 
            farbe: Farbe;
            wert: Wert;
         END;

   VAR 
      skatblatt : ARRAY [a..b] OF Skatkarte;
      k, K, i   : INTEGER;
      paar      : BOOLEAN;
      zaehlen   : ARRAY Wert OF INTEGER;

      (* gebe Karte aus *)
   PROCEDURE WriteKarte(karte: Skatkarte);
   BEGIN 
      CASE karte.farbe OF 
      | Kreuz: 
            WriteString("Kreuz ");
      | Pik: 
            WriteString("Pik ");
      | Herz: 
            WriteString("Herz ");
      | Karo: 
            WriteString("Karo ");
      END;

      CASE karte.wert OF 
      | As: 
            WriteString("As");
      | Koenig: 
            WriteString("Koenig");
      | Dame: 
            WriteString("Dame");
      | Bube: 
            WriteString("Bube");
      | Zehn: 
            WriteString("10");
      | Neun: 
            WriteString("9");
      | Acht: 
            WriteString("8");
      | Sieben: 
            WriteString("7");
      END;
   END WriteKarte;

   (* gebe eine Blatt aus *)

   PROCEDURE WriteBlatt(blatt: ARRAY OF Skatkarte; n: INTEGER);
      VAR 
         i: INTEGER;
   BEGIN 
      FOR i := 0 TO n-1 DO 
         WriteKarte(blatt[i]);
         WriteString("   ");
      END;
      WriteLn;
   END WriteBlatt;

   (* skatblatt mit Karten fuellen *)

   PROCEDURE InitSkatblatt(VAR skatblatt: ARRAY OF Skatkarte);
      VAR 
         i    : INTEGER;
         farbe: Farbe;
         wert : Wert;
   BEGIN 
      i := 0;
      FOR farbe := Kreuz TO Karo DO 
         FOR wert := As TO Sieben DO 
            skatblatt[i].farbe := farbe;
            skatblatt[i].wert := wert;
            INC(i);
         END;
      END;
   END InitSkatblatt;

   (* mische die Karten durch n echte Vertauschungen *)

   PROCEDURE Mischen(VAR skatblatt: ARRAY OF Skatkarte; n: INTEGER);
      VAR 
         i, zahl1, zahl2: INTEGER;
         karte          : Skatkarte;
   BEGIN 
      FOR i := 1 TO n DO 
         zahl1 := Random(a, b) - 1;
         REPEAT 
            zahl2 := Random(a, b) - 1;
         UNTIL zahl1 <> zahl2;

         karte := skatblatt[zahl1];
         skatblatt[zahl1] := skatblatt[zahl2];
         skatblatt[zahl2] := karte;
      END;
   END Mischen;

(*************** Aufgabe 20 ***************************)

   PROCEDURE Paar(blatt: ARRAY OF Skatkarte; n: INTEGER) : BOOLEAN;
      VAR 
         i      : INTEGER;
         zaehlen: ARRAY Wert OF INTEGER;
         wert   : Wert;
   BEGIN 
      FOR wert := As TO Sieben DO 
         zaehlen[wert] := 0;
      END;

      FOR i := 0 TO n-1 DO 
         INC(zaehlen[blatt[i].wert]);
         IF zaehlen[blatt[i].wert] >= 2 THEN 
            RETURN TRUE;
         END;
      END;

      RETURN FALSE;
   END Paar;

   PROCEDURE Dreier(blatt: ARRAY OF Skatkarte; n: INTEGER) : BOOLEAN;
      VAR 
         i      : INTEGER;
         zaehlen: ARRAY Wert OF INTEGER;
         wert   : Wert;
   BEGIN 
      FOR wert := As TO Sieben DO 
         zaehlen[wert] := 0;
      END;

      FOR i := 0 TO n-1 DO 
         INC(zaehlen[blatt[i].wert]);
         IF zaehlen[blatt[i].wert] >= 3 THEN 
            RETURN TRUE;
         END;
      END;

      RETURN FALSE;
   END Dreier;

   PROCEDURE Vierer(blatt: ARRAY OF Skatkarte; n: INTEGER) : BOOLEAN;
      VAR 
         i      : INTEGER;
         zaehlen: ARRAY Wert OF INTEGER;
         wert   : Wert;
   BEGIN 
      FOR wert := As TO Sieben DO 
         zaehlen[wert] := 0;
      END;

      FOR i := 0 TO n-1 DO 
         INC(zaehlen[blatt[i].wert]);
         IF zaehlen[blatt[i].wert] >= 4 THEN 
            RETURN TRUE;
         END;
      END;

      RETURN FALSE;
   END Vierer;

   PROCEDURE DoppelPaar(blatt: ARRAY OF Skatkarte; n: INTEGER) : BOOLEAN;
      VAR 
         i      : INTEGER;
         zaehlen: ARRAY Wert OF INTEGER;
         wert   : Wert;
         paar   : BOOLEAN;
   BEGIN 
      FOR wert := As TO Sieben DO 
         zaehlen[wert] := 0;
      END;

      paar := FALSE;

      FOR i := 0 TO n-1 DO 
         INC(zaehlen[blatt[i].wert]);
         IF paar THEN 
            IF (zaehlen[blatt[i].wert] >= 2) & (wert <> blatt[i].wert) THEN 
               RETURN TRUE;
            END;
         ELSIF zaehlen[blatt[i].wert] >= 2 THEN 
            paar := TRUE;
            wert := blatt[i].wert;
         END;
      END;

      RETURN FALSE;
   END DoppelPaar;

   PROCEDURE FullHouse(blatt: ARRAY OF Skatkarte; n: INTEGER) : BOOLEAN;
      VAR 
         i               : INTEGER;
         zaehlen         : ARRAY Wert OF INTEGER;
         wert, dreierWert: Wert;
         dreier          : BOOLEAN;
   BEGIN 
      FOR wert := As TO Sieben DO 
         zaehlen[wert] := 0;
      END;

      dreier := FALSE;

      FOR i := 0 TO n-1 DO 
         INC(zaehlen[blatt[i].wert]);
         IF zaehlen[blatt[i].wert] >= 3 THEN 
            dreier := TRUE;
            dreierWert := blatt[i].wert;
         END;
      END;

      IF dreier THEN 
         FOR wert := As TO Sieben DO 
            IF (zaehlen[wert] >= 2) & (wert <> dreierWert) THEN 
               RETURN TRUE;
            END;
         END;
      END;

      RETURN FALSE;
   END FullHouse;

   PROCEDURE Spielen(blatt: ARRAY OF Skatkarte; anzahl: INTEGER; VAR spieler,
      bank: INTEGER);
   BEGIN 
      IF Vierer(blatt, anzahl) THEN 
         WriteString("Vierer");
         INC(spieler, 9);
         DEC(bank, 9);
      ELSIF FullHouse(blatt, anzahl) THEN 
         WriteString("FullHouse");
         INC(spieler, 7);
         DEC(bank, 7);
      ELSIF Dreier(blatt, anzahl) THEN 
         WriteString("Dreier");
         INC(spieler, 5);
         DEC(bank, 5);
      ELSIF DoppelPaar(blatt, anzahl) THEN 
         WriteString("DoppelPaar");
         INC(spieler, 3);
         DEC(bank, 3);
      ELSIF Paar(blatt, anzahl) THEN 
         WriteString("Paar");
         INC(spieler);
         DEC(bank);
      ELSE 
         WriteString("--");
         DEC(spieler);
         INC(bank);
      END;
   END Spielen;

BEGIN 
   InitSkatblatt(skatblatt);

   k := 50;
   K := 200;

   i := 0;
   WHILE (i<spiele) & (k>0) & (K>0) DO 
      INC(i);
      Mischen(skatblatt, 5000);
      WriteBlatt(skatblatt, anzahl);
      WriteString("     => ");

      Spielen(skatblatt, anzahl, k, K);

      WriteString("          Spieler = ");
      WriteInt(k, 0);
      WriteString("          Bank = ");
      WriteInt(K, 0);
      WriteLn;
   END;
END skat.