home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / 1991 / 07_08 / titel / hase_jae.pas < prev   
Encoding:
Pascal/Delphi Source File  |  1991-04-24  |  14.3 KB  |  442 lines
  1. (* ------------------------------------------------------ *)
  2. (*                     HASE&JÄG.PAS                       *)
  3. (*       Ein Strategie-Experiment in Turbo Pascal         *)
  4. (*         (c) 1991 Wolfgang Bartsch & TOOLBOX            *)
  5. (* ------------------------------------------------------ *)
  6.  
  7. PROGRAM Hase_und_Jaeger;
  8. USES Crt;
  9.  
  10. TYPE An_der_Reihe = (Mensch, Computer);
  11.      Position = RECORD Zeile, Spalte : BYTE END;
  12.  
  13. CONST Wartezeit = 500;
  14.  
  15. VAR Feld : ARRAY[0..9, 0..9] OF BYTE;
  16.     Jaeger : ARRAY[1..4] OF Position;
  17.     ZugListe : ARRAY[1..8] OF Position;
  18.     T : Position;
  19.     K, Anzahl, ZeilenMax, ZeilenMin,
  20.     JNR, JZ, JS, NR, HZ, HS,
  21.     Staerke, Ze, Sp : BYTE;
  22.     Spieler : An_der_Reihe;
  23.     OK, Computer_verliert, Mensch_verliert : BOOLEAN;
  24.     Taste : CHAR;
  25.  
  26. PROCEDURE Init;
  27. VAR Z, S : BYTE;
  28. BEGIN
  29.   FOR Z := 0 TO 9 DO
  30.     FOR S := 0 TO 9 DO Feld[Z, S] := 0; { verbotene Felder }
  31.   FOR Z := 1 TO 8 DO
  32.     FOR S := 1 TO 8 DO BEGIN
  33.       IF Odd(Z) AND Odd(S) THEN Feld[Z, S] := 1;
  34.       IF NOT Odd(Z) AND NOT Odd(S) THEN Feld[Z, S] := 1;
  35.       { erlaubte Felder }
  36.       IF (Z = 8) AND NOT Odd(S) THEN Feld[Z, S] := 2;
  37.       { Jäger }
  38.     END;
  39.   FOR Z:=1 TO 4 DO BEGIN
  40.     Jaeger[Z].Zeile := 8;
  41.     Jaeger[Z].Spalte := 2 * Z
  42.   END;
  43.   HZ := 1;
  44.   HS := 5;
  45.   Feld[HZ, HS] := 8  { Hase }
  46. END;
  47.  
  48. PROCEDURE Spielfeld;
  49. VAR Sp, Ze, K, Z, S : INTEGER;
  50. BEGIN
  51.   ClrScr; TextColor(LightMagenta); GotoXY(20, 3);
  52.   Write('H  a  s  e    und    J  ä  g  e  r');
  53.   TextColor(Yellow); Sp := 7; Ze := 6; GotoXY(Sp, Ze);
  54.   Write('    1   2   3   4   5   6   7   8');
  55.   GotoXY(Sp, Ze + 1);
  56.   Write('  ┌───┬───┬───┬───┬───┬───┬───┬───┐');
  57.   FOR K := 1 TO 7 DO BEGIN
  58.     GotoXY(Sp, Ze + 2 * K);
  59.     Write(K, ' │   │   │   │   │   │   │   │   │', K:2);
  60.     GotoXY(Sp, Ze + 1 + 2 * K);
  61.     Write('  ├───┼───┼───┼───┼───┼───┼───┼───┤')
  62.   END;
  63.   GotoXY(Sp, Ze + 16);
  64.   Write('8 │   │   │   │   │   │   │   │   │ 8');
  65.   GotoXY(Sp, Ze + 17);
  66.   Write('  └───┴───┴───┴───┴───┴───┴───┴───┘');
  67.   GotoXY(Sp, Ze + 18);
  68.   Write('    1   2   3   4   5   6   7   8');
  69.   FOR Z := 1 TO 8 DO
  70.     FOR S := 1 TO 8 DO BEGIN
  71.       GotoXY(Sp + 3 + (S - 1) * 4, Ze + 2 * Z);
  72.       IF Feld[Z, S] = 0 THEN BEGIN
  73.         TextColor(Yellow);
  74.         Write('▓▓▓');
  75.       END;
  76.       IF Feld[Z, S] = 2 THEN BEGIN
  77.         Write(' ');
  78.         TextColor(LightRed);
  79.         Write('O');
  80.       END;
  81.       IF Feld[Z, S] = 8 THEN BEGIN
  82.         Write(' ');
  83.         TextColor(LightGreen);
  84.         Write('X')
  85.       END;
  86.     END;
  87. END;
  88.  
  89. PROCEDURE Eingabe(VAR I, J : BYTE);
  90. VAR Sp, Ze : INTEGER;
  91.     Taste : CHAR;
  92. BEGIN
  93.   Sp := 50; Ze := 9; TextColor(White);
  94.   GotoXY(Sp, Ze); Write('Deine Eingabe');
  95.   GotoXY(Sp + 2, Ze + 2); Write('(   │   )');
  96.   GotoXY(Sp + 4, Ze + 2);
  97.   REPEAT Taste := ReadKey UNTIL Taste IN['1'..'8'];
  98.   Write(Taste); I := Ord(Taste) - Ord('0');
  99.   GotoXY(Sp + 8, Ze + 2);
  100.   REPEAT Taste := ReadKey UNTIL Taste IN['1'..'8'];
  101.   Write(Taste); J := Ord(Taste) - Ord('0');
  102. END;
  103.  
  104. PROCEDURE Fehler;
  105. VAR K : INTEGER;
  106. BEGIN
  107.   FOR K := 1 TO 2 DO BEGIN
  108.     GotoXY(50, 13); TextColor(LightMagenta + Blink);
  109.     Write('Fehlerhafte Eingabe !'); Delay(Wartezeit);
  110.     GotoXY(50, 13); TextColor(LightCyan + Blink);
  111.     Write('Bitte wiederholen !  '); Delay(Wartezeit);
  112.   END;
  113.   GotoXY(50, 13); ClrEoL
  114. END;
  115.  
  116. FUNCTION Hase_eingemauert : BOOLEAN;
  117. BEGIN
  118.   Hase_eingemauert := (Feld[HZ - 1, HS - 1] <> 1) AND
  119.                       (Feld[HZ - 1, HS + 1] <> 1) AND
  120.                       (Feld[HZ + 1, HS + 1] <> 1) AND
  121.                       (Feld[HZ + 1, HS - 1] <> 1)
  122. END;
  123.  
  124. PROCEDURE Zugliste_erstellen(VAR N : BYTE; Stark : BOOLEAN);
  125. VAR Z, K, Spalte_links, Spalte_rechts : BYTE;
  126. BEGIN
  127.   ZeilenMax := 0; ZeilenMin := 9; N := 0;
  128.   FOR K := 1 TO 4 DO BEGIN
  129.     Z := Jaeger[K].Zeile - 1;
  130.     IF Z + 1 > ZeilenMax THEN ZeilenMax := Z + 1;
  131.     IF Z + 1 < ZeilenMin THEN ZeilenMin := Z + 1;
  132.     ZugListe[2 * K - 1].Zeile := Z;
  133.     ZugListe[2 * K].Zeile := Z;
  134.     Spalte_links := Jaeger[K].Spalte - 1;
  135.     Spalte_rechts := Jaeger[K].Spalte + 1;
  136.     IF ((Feld[Z, Spalte_links] = 8) OR
  137.         (Feld[Z, Spalte_rechts] = 8)) AND Stark THEN BEGIN
  138.       ZugListe[2 * K - 1].Spalte := 0;
  139.       ZugListe[2 * K].Spalte := 0;
  140.     END
  141.                   { diagonal stehender Jäger bleibt stehen }
  142.     ELSE
  143.       IF ((HS=Jaeger[K].Spalte)
  144.           AND (Jaeger[K].Zeile - HZ = 2))
  145.          AND Stark THEN BEGIN
  146.         ZugListe[2 * K - 1].Spalte := 0;
  147.         ZugListe[2 * K].Spalte := 0;
  148.       END         { gegenüberstehender Jäger bleibt stehen }
  149.       ELSE BEGIN
  150.         IF Feld[Z,Spalte_links] = 1 THEN BEGIN
  151.           Inc(N);
  152.           ZugListe[2 * K - 1].Spalte := Spalte_links;
  153.         END ELSE
  154.           ZugListe[2 * K - 1].Spalte := 0;
  155.          IF Feld[Z, Spalte_rechts] = 1 THEN BEGIN
  156.            Inc(N);
  157.            ZugListe[2 * K].Spalte := Spalte_rechts;
  158.          END
  159.          ELSE
  160.            ZugListe[2*K].Spalte:=0
  161.       END
  162.     END
  163. END;
  164.  
  165. PROCEDURE StrategieZug(VAR N : BYTE);
  166. VAR K, L, M : LONGINT;
  167. BEGIN
  168.   L := 0; M := ZeilenMax;
  169.   FOR K := 1 TO 4 DO
  170.     L := 100 * L + 10 * Jaeger[K].Zeile + Jaeger[K].Spalte;
  171.   L := L - (M - 4) * 10101010;
  172.   N := 0; { falls kein Strategiezug möglich ist }
  173.   IF L = 42444648 THEN
  174.     IF Feld[M - 1, 7] = 8 THEN N := 2 ELSE N := 7;
  175.   IF L = 42444637 THEN
  176.     IF Feld[M - 1, 5] = 8 THEN N := 2 ELSE N := 5;
  177.   IF L = 42443537 THEN
  178.     IF Feld[M - 1, 3] = 8 THEN N := 7 ELSE N := 3;
  179.   IF L = 42333537 THEN N := 1;
  180.   IF L = 42332426 THEN N := 3;
  181.   IF L = 42442426 THEN N := 3;
  182.   IF L = 41434547 THEN
  183.     IF Feld[M - 1, 2] = 8 THEN N := 7 ELSE N := 2;
  184.   IF L = 32434547 THEN
  185.     IF Feld[M - 1, 4] = 8 THEN N := 7 ELSE N := 4;
  186.   IF L = 32344547 THEN
  187.     IF Feld[M - 1, 6] = 8 THEN N := 2 ELSE N := 6;
  188.   IF L = 32343647 THEN
  189.     IF Feld[M - 1, 8] = 8 THEN N := 6 ELSE N := 8;
  190.   IF L = 42443526 THEN
  191.     IF Feld[M - 1, 3] = 8 THEN N := 7 ELSE N := 3;
  192.   IF L = 42333526 THEN
  193.     IF Feld[M - 3, 5] = 8 THEN N := 4
  194.     ELSE IF Feld[M - 1, 1] = 8 THEN N := 3 ELSE N := 1;
  195.   IF L = 41434536 THEN
  196.     IF Feld[M - 2, 2] = 8 THEN N := 5 ELSE N := 2;
  197.   IF L = 23254547 THEN N := 6;
  198.   IF L = 23253647 THEN
  199.     IF Feld[M - 1, 8] = 8 THEN N := 6 ELSE N := 8;
  200.   IF L = 23344547 THEN
  201.     IF Feld[M - 1, 6] = 8 THEN N := 4 ELSE N := 6;
  202.   IF L = 23343647 THEN
  203.     IF Feld[M - 3, 4] = 8 THEN N := 5
  204.     ELSE IF Feld[M - 1, 8] = 8 THEN N := 6 ELSE N := 8;
  205.   IF L = 33444637 THEN
  206.     IF Feld[M - 1, 5] = 8 THEN N := 2 ELSE N := 5;
  207.   IF L = 33443537 THEN
  208.     IF Feld[M - 2, 4] = 8 THEN N := 7 ELSE N := 1;
  209.   IF L = 22443537 THEN N := 3;
  210.   IF L = 42243526 THEN
  211.     IF Feld[M - 4, 4] = 8 THEN N := 2 ELSE N := 8;
  212.   IF L = 42243517 THEN N := 6;
  213.   IF L = 41433436 THEN
  214.     IF Feld[M - 1, 2] = 8 THEN N := 7 ELSE N := 2;
  215.   IF L = 32433436 THEN
  216.     IF Feld[M - 2, 5] = 8 THEN N := 2 ELSE N := 6;
  217.   IF L = 33444648 THEN
  218.     IF Feld[M - 1, 7] = 8 THEN N := 4 ELSE N := 7;
  219.   IF L = 24444637 THEN N := 5;
  220.   IF L = 33443526 THEN
  221.     IF Feld[M - 3, 3] = 8 THEN N := 1
  222.     ELSE IF Feld[M - 2, 4] = 7 THEN N := 6 ELSE N := 2;
  223.   IF L = 22443526 THEN N := 3;
  224.   IF L = 24443526 THEN
  225.     IF Feld[M - 4, 6] = 8 THEN N := 6 ELSE N := 3;
  226.   IF L = 24443517 THEN N := 6;
  227.   IF L = 24442617 THEN N := 3;
  228.   IF L = 32434536 THEN
  229.     IF Feld[M - 1, 4] = 8 THEN N := 2 ELSE N := 4;
  230.   IF L = 23434536 THEN N := 4;
  231.   IF L = 32432536 THEN N := 4;
  232.   IF L = 33354648 THEN
  233.     IF Feld[M - 1, 7] = 8 THEN N := 2 ELSE N := 7;
  234.   IF L = 24443537 THEN N := 3;
  235.   IF L = 43344547 THEN N := 1;
  236.   IF L = 42443546 THEN N := 8;
  237.   IF L = 33354637 THEN
  238.     IF Feld[M - 2, 4] = 8 THEN N := 7 ELSE N := 3;
  239.   IF L = 43344536 THEN N := 1;
  240.   IF L = 42242617 THEN N := 2;
  241.   IF L = 43343627 THEN N := 1;
  242.   IF L = 23342547 THEN
  243.     IF Feld[M - 4, 3] = 8 THEN N := 1 ELSE N := 7;
  244.   IF L = 33244637 THEN N := 5;
  245.   IF L = 32344536 THEN
  246.     IF Feld[M - 2, 5] = 8 THEN N := 2 ELSE N := 8;
  247.   IF L = 32344527 THEN N := 6;
  248.   IF L = 12342547 THEN N := 3;
  249.   IF L = 23344536 THEN
  250.     IF Feld[M - 3, 6] = 8 THEN N := 8
  251.     ELSE IF Feld[M - 2, 5] = 8 THEN N := 2 ELSE N := 7;
  252.   IF L = 23344527 THEN N := 6;
  253.   IF L = 12232547 THEN N := 7;
  254.   IF L = 12342545 THEN N := 3;
  255.   IF L = 23342545 THEN
  256.     IF Feld[M - 3, 6] = 8 THEN N := 8
  257.     ELSE IF Feld[M - 4, 3] = 8 THEN N := 1 ELSE N := 2;
  258.   IF L = 12232545 THEN N := 8;
  259.   IF L = 33443546 THEN N := 8;
  260.   IF L = 22333546 THEN N := 8;
  261. END;
  262.  
  263. FUNCTION Frei(N : BYTE) : BOOLEAN;
  264. VAR K : BYTE;
  265. BEGIN
  266.  Frei := TRUE;
  267.  FOR K := 1 TO 4 DO
  268.    IF (K <> (N + 1) DIV 2) AND (ZugListe[N].Spalte > 0) THEN
  269.      IF ZugListe[N].Spalte = Jaeger[K].Spalte THEN
  270.        Frei := FALSE
  271. END;
  272.  
  273. PROCEDURE Zufall(VAR N : BYTE);
  274. VAR V : BYTE;
  275. BEGIN
  276.   V := 0;
  277.   REPEAT
  278.     N := Random(8) + 1; Inc(V)
  279.   UNTIL (V = 200) OR ((ZugListe[N].Spalte > 0) AND
  280.         (ZeilenMax - ZugListe[N].Zeile < 3) AND Frei(N));
  281.   IF V = 200 THEN
  282.     REPEAT
  283.       N := Random(8) + 1
  284.     UNTIL ZugListe[N].Spalte > 0;
  285. END;
  286.  
  287. PROCEDURE ZufallsZug(VAR N : BYTE);
  288. VAR Zug, K : BYTE;
  289.     Min, Entfernung : INTEGER;
  290.     Zuege : ARRAY[1..4] OF BYTE;
  291. BEGIN
  292.   Zug := 0;
  293.   FOR K := 1 TO 8 DO BEGIN
  294.     IF (ZugListe[K].Spalte > 0) AND
  295.        (ZeilenMax - ZugListe[K].Zeile < 3) THEN BEGIN
  296.    { Feld besetzen, das vom Hasen aus erreicht werden kann }
  297.       IF ((HZ - 1 = ZugListe[K].Zeile) AND
  298.           (HS - 1 = ZugListe[K].Spalte)) OR
  299.          ((HZ - 1 = ZugListe[K].Zeile) AND
  300.           (HS + 1 = ZugListe[K].Spalte)) OR
  301.          ((HZ + 1 = ZugListe[K].Zeile) AND
  302.           (HS + 1 = ZugListe[K].Spalte)) OR
  303.          ((HZ + 1 = ZugListe[K].Zeile) AND
  304.           (HS - 1 = ZugListe[K].Spalte)) THEN BEGIN
  305.         Inc(Zug);
  306.         Zuege[Zug] := K;
  307.       END;
  308.     END;
  309.   END;
  310.   IF Zug > 0 THEN N := Zuege[Random(Zug) + 1]
  311.               { mehrere Felder, die besetzt werden könnten }
  312.   ELSE BEGIN
  313.     Min := 200;
  314.                   { der Jäger mit der kleinsten Entfernung }
  315.                   { zum Hasen wird gesetzt                 }
  316.     FOR K := 1 TO 8 DO
  317.       IF ZugListe[K].Spalte > 0 THEN BEGIN
  318.         Entfernung := Sqr(ZugListe[K].Zeile - HZ) +
  319.                       Sqr(ZugListe[K].Spalte - HS);
  320.         IF (Entfernung < Min) AND
  321.            (ZeilenMax - ZugListe[K].Zeile < 3) THEN BEGIN
  322.           Min := Entfernung;
  323.           N := K
  324.         END;
  325.       END;
  326.   END;
  327.   IF N = 0 THEN Zufall(N)
  328. END;
  329.  
  330. BEGIN                                      { Hauptprogramm }
  331.   REPEAT
  332.     TextBackground(Blue); TextColor(Yellow); Randomize;
  333.     ClrScr; Init;
  334.     GotoXY(10,5); Write('Welche Spielstärke (1/2/3/4/5)? ');
  335.     REPEAT
  336.       Taste:=ReadKey
  337.     UNTIL Taste IN ['1'..'5'];
  338.     Write(Taste);
  339.     Staerke := Ord(Taste) - Ord('0');
  340.     GotoXY(10, 7);
  341.     Write('Willst du den ersten Zug setzen (J/N)? ');
  342.     REPEAT
  343.       Taste:=UpCase(ReadKey)
  344.     UNTIL Taste IN ['J', 'N'];
  345.     IF Taste = 'J' THEN Spieler := Mensch
  346.                    ELSE Spieler := Computer;
  347.     Computer_verliert := FALSE;
  348.     Mensch_verliert := FALSE;
  349.     Spielfeld;
  350.     GotoXY(50, 15);
  351.     Write('Spielstärke ', Staerke); ZeilenMax := 8;
  352.     ZeilenMin := 8; HZ := 1;
  353.     REPEAT
  354.       IF Spieler = Mensch THEN BEGIN
  355.         REPEAT
  356.           OK := FALSE; Eingabe(Ze, Sp);
  357.           IF (Sqr(HZ - Ze) + Sqr(HS - Sp) = 2) AND
  358.              (Feld[Ze, Sp] = 1) THEN OK := TRUE
  359.           ELSE Fehler
  360.         UNTIL OK;
  361.         GotoXY(10 + (HS - 1) * 4, 6 + 2 * HZ);
  362.         Write('  ');
  363.         Feld[HZ, HS] := 1;
  364.         HZ := Ze; HS := Sp;
  365.         GotoXY(10 + (HS - 1) * 4, 6 + 2 * HZ); Write(' ');
  366.         TextColor(LightGreen); Write('X');
  367.         TextColor(Yellow); Feld[HZ, HS] := 8;
  368.         Zugliste_erstellen(Anzahl, FALSE);
  369.         IF (HZ >= ZeilenMax) OR (Anzahl = 0) THEN
  370.           Computer_verliert := TRUE
  371.       END ELSE BEGIN
  372.         IF Random(100) < 20 * Staerke THEN BEGIN
  373.           Zugliste_erstellen(Anzahl, FALSE);
  374.           StrategieZug(NR);
  375.           IF (NR = 0) OR (ZugListe[NR].Spalte = 0) THEN
  376.             ZufallsZug(NR)
  377.         END ELSE BEGIN
  378.           IF ZeilenMin>HZ+1 THEN BEGIN
  379.             Zugliste_erstellen(Anzahl, FALSE);
  380.             StrategieZug(NR);
  381.             IF (NR = 0) OR (ZugListe[NR].Spalte = 0) THEN
  382.               ZufallsZug(NR)
  383.           END ELSE BEGIN
  384.             Zugliste_erstellen(Anzahl, TRUE);
  385.             IF Anzahl = 0 THEN
  386.               Zugliste_erstellen(Anzahl, FALSE);
  387.             IF Staerke = 1 THEN Zufall(NR)
  388.                            ELSE ZufallsZug(NR)
  389.           END;
  390.         END;
  391.         JNR := (NR + 1) DIV 2;
  392.         JZ := Jaeger[JNR].Zeile;
  393.         JS := Jaeger[JNR].Spalte;
  394.         GotoXY(10 + (JS - 1) * 4, 6 + 2 * JZ);
  395.         Write('  ');
  396.         Feld[JZ, JS] := 1;
  397.         JZ := ZugListe[NR].Zeile;
  398.         JS := ZugListe[NR].Spalte;
  399.         Jaeger[JNR].Zeile := JZ;
  400.         Jaeger[JNR].Spalte := JS;
  401.         GotoXY(10 + (JS - 1) * 4, 6 + 2 * JZ);
  402.         Write(' ');
  403.         TextColor(LightRed); Write('O');
  404.         TextColor(Yellow); Feld[JZ, JS] := 2;
  405.         TextColor(LightCyan); GotoXY(50, 18);
  406.         Write('Computer setzt auf ( ', JZ, ' │ ', JS, ' )');
  407.         TextColor(Yellow); Delay(Wartezeit);
  408.         FOR K := 1 TO 3 DO
  409.           IF (Jaeger[K].Spalte = Jaeger[K + 1].Spalte) AND
  410.              (Jaeger[K].Zeile > Jaeger[K + 1].Zeile) THEN
  411.           BEGIN
  412.             T := Jaeger[K];
  413.             Jaeger[K] := Jaeger[K + 1];
  414.             Jaeger[K + 1] := T
  415.           END;
  416.         IF Hase_eingemauert THEN
  417.           Mensch_verliert:=TRUE;
  418.         Zugliste_erstellen(Anzahl, FALSE);
  419.         IF (HZ >= ZeilenMax) OR (Anzahl = 0) THEN
  420.           Computer_verliert := TRUE
  421.       END;
  422.       IF Spieler=Mensch THEN Spieler:=Computer
  423.                         ELSE Spieler:=Mensch
  424.     UNTIL Computer_verliert OR Mensch_verliert;
  425.     GotoXY(51, 22); TextColor(Yellow);
  426.     IF Computer_verliert THEN BEGIN
  427.       Write('Der Hase hat die Jägerkette');
  428.       GotoXY(51,23); Write('durchbrochen!')
  429.     END;
  430.     IF Mensch_verliert THEN
  431.       Write('Der Hase ist umzingelt!');
  432.     GotoXY(5,25); Write('Drücke die <LEERTASTE>');
  433.     REPEAT Taste:=ReadKey UNTIL Taste=' ';
  434.     TextBackground(Black); TextColor(LightGray); ClrScr;
  435.     GotoXY(30, 11); Write('Noch einmal (J/N): ');
  436.     REPEAT Taste:=UpCase(ReadKey) UNTIL Taste IN['J','N']
  437.   UNTIL Taste='N'
  438. END.
  439.  
  440. (* ------------------------------------------------------ *)
  441. (*               Ende von HASE&JÄG.PAS                    *)
  442.