home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / 1991 / 09_10 / explode / bestrafe.c next >
Encoding:
C/C++ Source or Header  |  1991-08-08  |  25.2 KB  |  1,140 lines
  1. /*-------------------------------------------------------------------
  2.  DER BESTRAFER wurde anläßlich einer  unbedachten   Äußerung  unseres
  3.  Jungredakteurs Gerald Arend ins Leben gerufen.  Dem  unnachahmlichen
  4.  und mir zum  Verwechseln  ähnlichen  Horst Brack  (Catch up, RTL) zu
  5.  Ehren bekam mein Programm  diesen gefürchteten Namen.
  6.  Nachdem  vorgenannter   Jungredakteur sein doch arg schwachbrüstiges
  7.  Programm  "Volon-Tier"  (toolbox 07/08 91, Databox-Spezial EXPLODE+)
  8.  als  das  "Nonplusultra"  in  Sachen EXPLODE-Algorithmus im deutsch-
  9.  sprachigen Raum verkaufen wollte, war es Zeit,  einen "BESTRAFER" zu
  10.  programmieren.
  11.  Das dann spontan ins Leben gerufene Turnier fand  zwischen dem Nach-
  12.  folgeprogramm "EXTERMINATOR" von Gerald Arend und meinem "BESTRAFER"
  13.  statt. Beide Programme finden sich auf der Databox 09/10 zur letzten
  14.  alten toolbox.
  15.  Das Turnier endete nach 14 Spielen  13 zu 1  für den "EXTERMINATOR",
  16.  wobei zur Ehrenrettung des "BESTRAFERS"  gesagt werden muß,  daß die
  17.  Entscheidung ob Sieg oder Niederlage  meist  an  einem  einzigen Zug
  18.  hing.  Beide  Programme  bauen auf  einem  völlig unterschiedlichen,
  19.  nicht-rekursiven allgemeinen Algorithmus auf.
  20.  In  die  Entwicklung  des  "BESTRAFERS" wurden 20 Programmierstunden,
  21.  circa 10 Liter Cola sowie mehrere Kannen Kaffee investiert.
  22.  Ein  Großteil  der  Entwicklungszeit  mußte  leider auf Debugging von
  23.  Seiteneffekten bei logischen Operationen mit Quick-C verwendet werden.
  24.  
  25.  Zum Schluß dieses kleinen  Vorwortes  möchte  ich  mich  noch  einmal
  26.  persönlich bei allen Lesern für Ihre Treue bedanken.
  27.  Die Arbeit in der  toolbox-Redaktion  war  geprägt  von Spontaneität,
  28.  Freude am Programmieren sowie einem Freiraum für Individualismus und
  29.  Kreativität.  Ich selbst werde an anderer Stelle versuchen, ähnliche
  30.  Akzente zu setzen.
  31.  Allen Lesern wünsche ich ein kritisches Auge, Mut zum  eigenen  Stil
  32.  und viel Spaß am Programmieren, auch ohne eine toolbox im alten Sinne.
  33.  Vielleicht "sieht" man sich ja auf die eine oder andere Art wieder.
  34.  Auch die Frage, ob es je wieder eine toolbox alter Prägung geben wird,
  35.  hängt einzig und alleine vom Rechenschieber und Ihnen als Leser ab.
  36.  
  37.  Ihr Ulrich Schmitz
  38.  
  39.  Eschwege, den 25.06.1991
  40. */
  41.  
  42.  
  43.  
  44. #include<graph.h>
  45. #include<stdio.h>
  46. #include<conio.h>
  47. #include<stdlib.h>
  48. #include <sys\types.h>
  49. #include <sys\timeb.h>
  50.  
  51. #define TRUE 1
  52. #define FALSE 0
  53. #define COMPUTER 12    /* Farbe Rot  */
  54. #define MENSCH 9       /* Farbe Blau */
  55.  
  56. /* Globale Variablen -----------------------------------*/
  57.  
  58. int Feld[6][6], Spieler[6][6];
  59. int ZugA_F, Zug1_6;
  60. int Aktueller_Spieler;
  61. int rumsbums, Zug_Anzahl;
  62.  
  63. /* Funktionen und Prozeduren -------------------------------------*/
  64.  
  65. void pause(int zeit)
  66. {
  67. int i, ii, dummy;
  68. for ( i = 1; i <= zeit; i++ )
  69.     {
  70.      for (ii = 0; ii <= i; ii++)
  71.      {
  72.       ii = ii;
  73.       i = i;
  74.      }
  75.     }
  76. }
  77.  
  78. /*----------------------------------------------------------------*/
  79.  
  80. void tastatur_eingabe()
  81. {
  82.  int taste;
  83.  char t[] = " \0";
  84.  char ct;
  85.  Zug_Anzahl++;
  86.  
  87. _settextcolor(MENSCH);
  88. _settextposition(7,39);
  89. _outtext(" Ihr Zug :  -             ");
  90.  
  91. do {
  92.  _settextposition(7,50);
  93.  _settextcolor(MENSCH);
  94.  taste = getch();
  95.  ct = (char) taste;
  96.  t[0] = ct;
  97.  _outtext(t);
  98. } while ( ct != 'A' &&
  99.       ct != 'a' &&
  100.       ct != 'B' &&
  101.       ct != 'b' &&
  102.       ct != 'C' &&
  103.       ct != 'c' &&
  104.       ct != 'D' &&
  105.       ct != 'd' &&
  106.       ct != 'E' &&
  107.       ct != 'e' &&
  108.       ct != 'F' &&
  109.       ct != 'f');
  110.  
  111. if (ct >= 'A' && ct <= 'F')
  112.     ZugA_F = (int) (ct - 'A');     /*  Wert 0 - 5  */
  113.  
  114. else if (ct >= 'a' && ct <= 'f')
  115.      ZugA_F = (int) (ct - 'a');    /*  Wert 0 - 5  */
  116.  
  117.  
  118. do {
  119.  _settextposition(7,52);
  120.  taste = getch();
  121.  ct = (char) taste;
  122.  t[0] = ct;
  123.  _outtext(t);
  124. } while ( ct != '1' &&
  125.       ct != '2' &&
  126.       ct != '3' &&
  127.       ct != '4' &&
  128.       ct != '5' &&
  129.       ct != '6');
  130. Zug1_6 = (int) (ct - '1'); /*  Wert 0 - 5  */
  131.  
  132. }
  133.  
  134. /*----------------------------------------------------------------*/
  135.  
  136. initialisieren()
  137. {
  138. int i, ii;
  139.  
  140. Zug_Anzahl = 0;
  141.  
  142. for (ii = 0; ii <= 5; ii++)
  143. for (i=0; i <= 5; i++)
  144.    {
  145.     Feld[i][ii] = 0;
  146.     Spieler[i][ii] = 0;
  147.    }
  148. }
  149.  
  150. /*----------------------------------------------------------------*/
  151.  
  152. int zug_okay()
  153. {
  154.  /**** Ist Feld noch frei oder von akt.Spieler besetzt ? ****/
  155.  if ( Feld[ZugA_F][Zug1_6] == 0 ||
  156.       Spieler[ZugA_F][Zug1_6] == Aktueller_Spieler )
  157.       return TRUE;
  158.  else return FALSE;
  159. }
  160.  
  161. /*----------------------------------------------------------------*/
  162.  
  163. void wer_beginnt()
  164. {
  165. char ct;
  166. _settextcolor(2);
  167. _settextposition(6, 39);
  168. _outtext(" Wer beginnt mit dem Spiel?");
  169. _settextposition(7, 39);
  170. _outtext("  estrafer /  pieler :");
  171.  
  172. _settextcolor(COMPUTER);
  173. _settextposition(7, 40);
  174. _outtext("B");
  175.  
  176. _settextcolor(MENSCH);
  177. _settextposition(7, 52);
  178. _outtext("S");
  179. _settextposition(7, 61);
  180.  
  181.  
  182. ct = (char) getch();
  183. if ( ct == 'S' ||
  184.      ct == 's' )
  185.      Aktueller_Spieler = MENSCH;
  186. else
  187.      Aktueller_Spieler = COMPUTER;
  188.  
  189. _settextposition(6,39);
  190. _outtext("                           ");
  191. _settextposition(7,39);
  192. _outtext("                           ");
  193.  
  194. }
  195.  
  196. /*----------------------------------------------------------------*/
  197.  
  198. int rnd()  /* Erzeugt eine Zufallszahl von 0 bis 5 */
  199. {
  200. int zufall;
  201. struct timeb tstruct;
  202.  ftime( &tstruct );
  203.  zufall = (int) (tstruct.millitm / 170);
  204. return zufall;
  205. }
  206.  
  207. /*----------------------------------------------------------------*/
  208.  
  209. void spielfeld()
  210. {
  211. int i, ii;
  212. char feldwert[] = " \0";
  213.  
  214.   for(ii = 0; ii <= 5; ii++)
  215.   {
  216.      for(i = 0; i <= 5; i++)
  217.      {
  218.       _settextposition(7+i*2, 13+ii*4);
  219.  
  220.       if ( Spieler[ii][i] == COMPUTER )
  221.        _settextcolor(COMPUTER);
  222.  
  223.       else if ( Spieler[ii][i] == MENSCH )
  224.         _settextcolor(MENSCH);
  225.  
  226.       else  _settextcolor(2);  /* Feld bisher leer --> grün  */
  227.  
  228.       feldwert[0] = (char) Feld[ii][i] + '0';
  229.       _outtext(feldwert);
  230.      }
  231.   }
  232. }
  233.  
  234. /*----------------------------------------------------------------*/
  235. int summenzug()
  236. {
  237. int i, x, y, summe, kleinste_summe, groesste_summe;
  238. int alle_summen[16], alle_x[16], alle_y[16];
  239. char s1[1], s2[1];
  240.  
  241. int max_wert[6][6] = {
  242.              { 1, 2, 2, 2, 2, 1 },
  243.              { 2, 3, 3, 3, 3, 2 },
  244.              { 2, 3, 3, 3, 3, 2 },
  245.              { 2, 3, 3, 3, 3, 2 },
  246.              { 2, 3, 3, 3, 3, 2 },
  247.              { 1, 2, 2, 2, 2, 1 }};
  248.  
  249.  
  250. for ( i = 0; i <= 15; i++)
  251.      {
  252.       alle_summen[i] = 0;
  253.       alle_x[i] = 0;
  254.       alle_y[i] = 0;
  255.      }
  256.  
  257. kleinste_summe = 99;
  258. groesste_summe = -1;
  259. i = 0;
  260.  
  261.  
  262. for ( x = 1; x <= 4; x++)
  263.     {
  264.      for ( y = 1; y <= 4; y++)
  265.      {
  266.       if (Spieler[x][y] != MENSCH)
  267.           {
  268.            summe = 0;
  269.            summe += Feld[x][y];
  270.            summe += Feld[x+1][y];
  271.            summe += Feld[x-1][y];
  272.            summe += Feld[x][y-1];
  273.            summe += Feld[x][y+1];
  274.            alle_summen[i] = summe;
  275.            alle_x[i] = x;
  276.            alle_y[i] = y;
  277.  
  278.            i++;
  279.           }
  280.            else
  281.           {
  282.            alle_summen[i] = 999;
  283.            i++;
  284.           }
  285.      }
  286.     }
  287.  
  288. if (Zug_Anzahl <= 42)
  289. {
  290.  for ( i = 0; i <= 15; i++ )
  291.     {
  292.       if ( alle_summen[i] <= kleinste_summe && Feld[alle_x[i]][alle_y[i]] < max_wert[alle_x[i]][alle_y[i]] )
  293.       {
  294.        kleinste_summe = alle_summen[i];
  295.        x = alle_x[i];
  296.        y = alle_y[i];
  297.        strcpy(s1,"▄");
  298.        strcpy(s2,"▀");
  299.       }
  300.     }
  301. }
  302. else
  303. {
  304.  strcpy(s1,"▌");
  305.  strcpy(s2,"▐");
  306.  for ( i = 0; i <= 15; i++ )
  307.     {
  308.       if ( alle_summen[i] >= groesste_summe )
  309.       {
  310.        groesste_summe = alle_summen[i];
  311.        x = alle_x[i];
  312.        y = alle_y[i];
  313.       }
  314.     }
  315. }
  316.  ZugA_F = x;
  317.  Zug1_6 = y;
  318.  
  319.  _settextcolor(COMPUTER);
  320.  _settextposition(14,45);
  321.  _outtext(s1);
  322.  pause(350);
  323.  _settextposition(14,45);
  324.  _outtext(s2);
  325.  pause(350);
  326.  _settextposition(14,45);
  327.  _outtext(" ");
  328.  _settextposition(14,49);
  329.  _outtext(s2);
  330.  pause(350);
  331.  _settextposition(14,49);
  332.  _outtext(s1);
  333.  pause(350);
  334.  _settextposition(14,49);
  335.  _outtext(" ");
  336.  _settextposition(14,53);
  337.  _outtext(s1);
  338.  pause(350);
  339.  _settextposition(14,53);
  340.  _outtext(s2);
  341.  pause(350);
  342.  _settextposition(14,53);
  343.  _outtext(" ");
  344.  _settextposition(14,57);
  345.  _outtext(s2);
  346.  pause(350);
  347.  _settextposition(14,57);
  348.  _outtext(s1);
  349.  pause(350);
  350.  _settextposition(14,57);
  351.  _outtext(" ");
  352.  
  353. return 17;
  354. }
  355.  
  356. /*----------------------------------------------------------------*/
  357.  
  358. void computer_zugberechnung()
  359. {
  360. int i,ii,x, y, Zug;
  361. int max_wert[6][6] = {
  362.              { 1, 2, 2, 2, 2, 1 },
  363.              { 2, 3, 3, 3, 3, 2 },
  364.              { 2, 3, 3, 3, 3, 2 },
  365.              { 2, 3, 3, 3, 3, 2 },
  366.              { 2, 3, 3, 3, 3, 2 },
  367.              { 1, 2, 2, 2, 2, 1 }};
  368.  
  369. static int endlos;
  370. Aktueller_Spieler = COMPUTER;
  371. Zug = FALSE;
  372.  
  373. i = rnd();
  374. /*-- Computer beginnt, Zufallszug gegen Langeweile ---*/
  375.  
  376. if (Zug_Anzahl == 0)
  377.    {
  378.     switch (i)
  379.     {
  380.      case 1:
  381.       ZugA_F = 0;
  382.       Zug1_6 = 0;
  383.       Zug = 1;
  384.      break;
  385.  
  386.      case 2:
  387.       ZugA_F = 5;
  388.       Zug1_6 = 0;
  389.       Zug = 1;
  390.      break;
  391.  
  392.      case 3:
  393.       ZugA_F = 0;
  394.       Zug1_6 = 5;
  395.       Zug = 1;
  396.      break;
  397.  
  398.      case 4:
  399.       ZugA_F = 5;
  400.       Zug1_6 = 5;
  401.       Zug = 1;
  402.      break;
  403.  
  404.      default:
  405.       ZugA_F = 0;
  406.       Zug1_6 = 0;
  407.       Zug = 1   ;
  408.     }
  409.  }
  410. /*-- Ende Spielbeginn mit Zufallszug -*/
  411.  
  412. /*-- Die Ecken besetzen, wenn beide Nachbarfelder nicht sprengbar sind -*/
  413.  
  414.  
  415. /* 1. Stufe ------------*/
  416. else if ( Feld[0][0] == 0 && Feld[0][1] <= 1 && Feld[1][0] <= 1 && Zug_Anzahl <= 50 )
  417.     {
  418.      ZugA_F = 0;
  419.      Zug1_6 = 0;
  420.      Zug = 2   ;
  421.     }
  422. else if ( Feld[5][5] == 0 && Feld[5][4] <= 1 && Feld[4][5] <= 1 && Zug_Anzahl <= 50)
  423.     {
  424.      ZugA_F = 5;
  425.      Zug1_6 = 5;
  426.      Zug = 3   ;
  427.     }
  428. else if ( Feld[0][5] == 0 && Feld[1][5] <= 1 && Feld[0][4] <= 1 && Zug_Anzahl <= 50)
  429.     {
  430.      ZugA_F = 0;
  431.      Zug1_6 = 5;
  432.      Zug = 4   ;
  433.     }
  434. else if ( Feld[5][0] == 0 && Feld[4][0] <= 1 && Feld[5][1] <= 1 && Zug_Anzahl <= 50)
  435.     {
  436.      ZugA_F = 5;
  437.      Zug1_6 = 0;
  438.      Zug = 5   ;
  439.     }
  440.  
  441. /* Ecke besetzt und ein sprengfähiges Nachbarfeld??  */
  442.  
  443. else if ( Spieler[0][0] == COMPUTER && ( (Feld[0][1] == 2 || Feld[1][0] == 2) && (Spieler[0][1] == MENSCH || Spieler[1][0] == MENSCH) ) )
  444.     {
  445.      ZugA_F = 0;
  446.      Zug1_6 = 0;
  447.      Zug = 6   ;
  448.     }
  449. else if ( Spieler[5][5] == COMPUTER && ( (Feld[5][4] == 2 || Feld[4][5] == 2) && (Spieler[5][4] == MENSCH || Spieler[4][5] == MENSCH) ) )
  450.     {
  451.      ZugA_F = 5;
  452.      Zug1_6 = 5;
  453.      Zug = 7   ;
  454.     }
  455. else if ( Spieler[0][5] == COMPUTER && ( (Feld[1][5] == 2 || Feld[0][4] == 2) && (Spieler[1][5] == MENSCH || Spieler[0][4] == MENSCH) ) )
  456.     {
  457.      ZugA_F = 0;
  458.      Zug1_6 = 5;
  459.      Zug = 8   ;
  460.     }
  461. else if ( Spieler[5][0] == COMPUTER && ( (Feld[4][0] == 2 || Feld[5][1] == 2) && (Spieler[4][0] == MENSCH || Spieler[5][1] == MENSCH) ) )
  462.     {
  463.      ZugA_F = 5;
  464.      Zug1_6 = 0;
  465.      Zug = 9   ;
  466.     }
  467.  
  468.  
  469. /*- Wenn ein Nachbarfeld bei Sprengung ebenfalls gesprengt wird, setzen -*/
  470. /* 2. Stufe ------------*/
  471.  
  472. else if ( Zug == FALSE )
  473.     {
  474.      for (x = 1; x <= 4; x++)
  475.      {
  476.       for (y = 1; y <= 4; y++)
  477.         {
  478.          if ( Spieler[x][y] == COMPUTER )
  479.          {
  480.          if (
  481.         ((Feld[x-1][y] == max_wert[x-1][y] && Spieler[x-1][y] == MENSCH) ||
  482.          (Feld[x+1][y] == max_wert[x+1][y] && Spieler[x+1][y] == MENSCH) ||
  483.          (Feld[x][y+1] == max_wert[x][y+1] && Spieler[x][y+1] == MENSCH) ||
  484.          (Feld[x][y-1] == max_wert[x][y-1] && Spieler[x][y-1] == MENSCH)) &&
  485.           (Feld[x][y] == max_wert[x][y])
  486.         )
  487.          {
  488.            ZugA_F = x;
  489.            Zug1_6 = y;
  490.            Zug = 10  ;
  491.            x = 5;
  492.            y = 5;
  493.          }
  494.           }
  495.          }
  496.       }
  497.       }
  498. /* Das gleiche für die Randfelder mit max_wert = 2 */
  499.      if ( Zug == FALSE )
  500.     {
  501.      for (y = 1; y <= 4; y++)
  502.      {
  503.      x = 0;
  504.      if ( Feld[x][y] == max_wert[x][y] && Spieler[x][y] == COMPUTER  &&
  505.           ((Feld[x+1][y] == max_wert[x+1][y] && Spieler[x+1][y] == MENSCH)  ||
  506.            (Feld[x][y+1] == max_wert[x][y+1] && Spieler[x][y+1] == MENSCH)  ||
  507.            (Feld[x][y-1] == max_wert[x][y-1] && Spieler[x][y-1] == MENSCH))
  508.         )
  509.            {
  510.           ZugA_F = x;
  511.           Zug1_6 = y;
  512.           Zug = 11  ;
  513.           x = 5;
  514.           y = 5;
  515.            }
  516.       }
  517.        }
  518.  
  519.      if ( Zug == FALSE )
  520.     {
  521.      for (y = 1; y <= 4; y++)
  522.      {
  523.      x = 5;
  524.      if ( Feld[x][y] == max_wert[x][y] && Spieler[x][y] == COMPUTER &&
  525.           ((Feld[x-1][y] == max_wert[x-1][y]) && (Spieler[x-1][y] == MENSCH) ||
  526.            (Feld[x][y+1] == max_wert[x][y+1]) && (Spieler[x][y+1] == MENSCH) ||
  527.            (Feld[x][y-1] == max_wert[x][y-1] && Spieler[x][y-1] == MENSCH))
  528.          )
  529.            {
  530.           ZugA_F = x;
  531.           Zug1_6 = y;
  532.           Zug = 12  ;
  533.           x = 5;
  534.           y = 5;
  535.            }
  536.        }
  537.        }
  538.  
  539.      if ( Zug == FALSE )
  540.     {
  541.      for (x = 1; x <= 4; x++)
  542.      {
  543.      y = 0;
  544.      if ( Feld[x][y] == max_wert[x][y] && Spieler[x][y] == COMPUTER  &&
  545.           ((Feld[x][y+1] == max_wert[x][y+1] && Spieler[x][y+1] == MENSCH)  ||
  546.            (Feld[x-1][y] == max_wert[x-1][y] && Spieler[x-1][y] == MENSCH)  ||
  547.            (Feld[x+1][y] == max_wert[x+1][y] && Spieler[x+1][y] == MENSCH))
  548.          )
  549.            {
  550.           ZugA_F = x;
  551.           Zug1_6 = y;
  552.           Zug = 13  ;
  553.           x = 5;
  554.           y = 5;
  555.            }
  556.       }
  557.        }
  558.  
  559.      if ( Zug == FALSE )
  560.     {
  561.      for (x = 1; x <= 4; x++)
  562.      {
  563.      y = 5;
  564.      if ( Feld[x][y] == max_wert[x][y] && Spieler[x][y] == COMPUTER &&
  565.           ((Feld[x][y-1] == max_wert[x][y-1] && Spieler[x][y-1] == MENSCH) ||
  566.            (Feld[x-1][y] == max_wert[x-1][y] && Spieler[x-1][y] == MENSCH) ||
  567.            (Feld[x+1][y] == max_wert[x+1][y] && Spieler[x+1][y] == MENSCH))
  568.          )
  569.            {
  570.           ZugA_F = x;
  571.           Zug1_6 = y;
  572.           Zug = 14  ;
  573.           x = 5;
  574.           y = 5;
  575.            }
  576.       }
  577.        }
  578.  
  579.  
  580.  
  581.  
  582.  
  583. /* 3. Stufe ------------ möglichst viele Felder sicher aufbauen */
  584.      if ( Zug == FALSE )
  585.     {
  586.      for (x = 1; x <= 4; x++)
  587.      {
  588.         for (y = 1; y <= 4; y++)
  589.         {
  590.          if (( Spieler[x][y] == COMPUTER) &&
  591.          ( Feld[x-1][y] < max_wert[x-1][y] ) && ( Feld[x-1][y] < max_wert[x][y] ) &&
  592.          ( Feld[x+1][y] < max_wert[x+1][y] ) && ( Feld[x+1][y] < max_wert[x][y] ) &&
  593.          ( Feld[x][y-1] < max_wert[x][y-1] ) && ( Feld[x][y-1] < max_wert[x][y] ) &&
  594.          ( Feld[x][y+1] < max_wert[x][y+1] ) && ( Feld[x][y+1] < max_wert[x][y] ) &&
  595.          ( Feld[x][y] < max_wert[x][y]    ))
  596.          {
  597.            ZugA_F = x;
  598.            Zug1_6 = y;
  599.            Zug = 15  ;
  600.            x = 5;
  601.            y = 5;
  602.          }
  603.          }
  604.      }
  605.       }
  606.  
  607. /* Wenn Spiel fortgeschritten ist (25 Doppelzüge), möglichst sprengen  */
  608.  
  609.      if ( Zug == FALSE && Zug_Anzahl > 50 )
  610.     {
  611.      for (x = 1; x <= 4; x++)
  612.      {
  613.         for (y = 1; y <= 4; y++)
  614.         {
  615.          if (( Spieler[x][y] == COMPUTER) &&
  616.          ( Feld[x-1][y] < max_wert[x-1][y] ) && ( Feld[x-1][y] < max_wert[x][y] ) &&
  617.          ( Feld[x+1][y] < max_wert[x+1][y] ) && ( Feld[x+1][y] < max_wert[x][y] ) &&
  618.          ( Feld[x][y-1] < max_wert[x][y-1] ) && ( Feld[x][y-1] < max_wert[x][y] ) &&
  619.          ( Feld[x][y+1] < max_wert[x][y+1] ) && ( Feld[x][y+1] < max_wert[x][y] ) &&
  620.          ( Feld[x][y] == max_wert[x][y]    ))
  621.          {
  622.            ZugA_F = x;
  623.            Zug1_6 = y;
  624.            Zug = 15  ;
  625.            x = 4;
  626.            y = 4;
  627.          }
  628.          }
  629.      }
  630.       }
  631.  
  632. /*- Keinen logisch-guten Zug gefunden -> Zufallszug ---*/
  633. /* 4. Stufe ------------*/
  634.  
  635.  if ( Zug == FALSE )
  636.     {
  637.      endlos++;
  638.      Zug = summenzug();
  639.      if ( endlos >= 6  )
  640.      {
  641.       _settextcolor(COMPUTER);
  642.       _settextposition(14,45);
  643.       _outtext("█");
  644.       pause(350);
  645.       _settextposition(14,45);
  646.       _outtext(" ");
  647.       _settextposition(14,49);
  648.       _outtext("█");
  649.       pause(350);
  650.       _settextposition(14,49);
  651.       _outtext(" ");
  652.       _settextposition(14,53);
  653.       _outtext("█");
  654.       pause(350);
  655.       _settextposition(14,53);
  656.       _outtext(" ");
  657.       _settextposition(14,57);
  658.       _outtext("█");
  659.       pause(350);
  660.       _settextposition(14,57);
  661.       _outtext(" ");
  662.       for (i=1; i<=6; i++)
  663.           {
  664.         for (ii=1; ii<=6; ii++)
  665.             {
  666.              if (Feld[i][ii] == 0)
  667.             {
  668.              ZugA_F = i;
  669.              Zug1_6 = ii;
  670.              Zug = 17;
  671.              ii=7;
  672.              i=7;
  673.              endlos = 0;
  674.             }
  675.              }
  676.         }
  677.       }
  678.      }
  679.  else
  680.  {
  681.  _settextcolor(COMPUTER);
  682.  _settextposition(14,45);
  683.  _outtext("▓");
  684.  pause(350);
  685.  _settextposition(14,45);
  686.  _outtext(" ");
  687.  _settextposition(14,49);
  688.  _outtext("▓");
  689.  pause(350);
  690.  _settextposition(14,49);
  691.  _outtext(" ");
  692.  _settextposition(14,53);
  693.  _outtext("▓");
  694.  pause(350);
  695.  _settextposition(14,53);
  696.  _outtext(" ");
  697.  _settextposition(14,57);
  698.  _outtext("▓");
  699.  pause(350);
  700.  _settextposition(14,57);
  701.  _outtext(" ");
  702.  endlos = 0;
  703.  }
  704. _settextposition(17,56);
  705. printf("%d", Zug_Anzahl/2 + 1);
  706.  
  707. }
  708.  
  709.  
  710. /*----------------------------------------------------------------*/
  711.  
  712. void computerzug()
  713. {
  714. int zulaessiger_zug;
  715.  
  716. Aktueller_Spieler = COMPUTER;
  717.  
  718. /*---------------------------------------*/
  719.  
  720. _settextcolor(COMPUTER);
  721. _settextposition(7,39);
  722. _outtext(" Der Bestrafer denkt nach!");
  723.  
  724. /*---------------------------------------*/
  725.  do {
  726.   computer_zugberechnung();
  727.   zulaessiger_zug = zug_okay();
  728.  } while ( zulaessiger_zug != TRUE );
  729.  
  730. _settextposition(11,50);
  731. printf("%c-%d", ZugA_F + 'A', Zug1_6 + 1);  /* Ausgabe des Comp. Zuges */
  732. Zug_Anzahl++;
  733. Spieler[ZugA_F][Zug1_6] = COMPUTER;
  734. Feld[ZugA_F][Zug1_6]++;
  735.  
  736. }
  737.  
  738. /*----------------------------------------------------------------*/
  739.  
  740. void zug_eingeben()
  741. {
  742. int erlaubter_zug;
  743.  
  744. Aktueller_Spieler = MENSCH;
  745.  
  746.  do {
  747.   tastatur_eingabe();
  748.   erlaubter_zug = zug_okay();
  749.  } while ( erlaubter_zug != TRUE );
  750.  
  751.  _settextcolor(COMPUTER);
  752.  _settextposition(7,50);
  753.  _outtext(" - ");
  754.  
  755.  Feld[ZugA_F][Zug1_6]++;
  756.  Spieler[ZugA_F][Zug1_6] = MENSCH;
  757.  
  758. }
  759.  
  760. /*----------------------------------------------------------------*/
  761.  
  762. void feld_zeichnen()
  763. {
  764. int i, ii;
  765. char c[] = "1\0";
  766. _clearscreen( _GCLEARSCREEN);
  767. _settextcolor(3);
  768. _settextposition(5,10);
  769. _outtext("   A   B   C   D   E   F");
  770.  
  771. for (i=7, ii=0; i <= 18; i+=2, ii++)
  772.  {
  773.   _settextposition(i, 9);
  774.   c[0] = (char) ii + '1';
  775.   _outtext(c);
  776.  }
  777.  
  778. _settextcolor(7);
  779. _settextposition(1,1);
  780. _outtext("  D E R   B E S T R A F E R,           (c) 1991 Ulrich Schmitz & toolbox");
  781. _settextposition(2,1);
  782. _outtext("     Offizieller Zweiter des toolbox-Explode-Turniers vom 25.06.1991");
  783. _settextposition(6,10);
  784. _outtext(" ╔═══╤═══╤═══╤═══╤═══╤═══╗");
  785. _settextposition(7,10);
  786. _outtext(" ║   │   │   │   │   │   ║");
  787. _settextposition(8,10);
  788. _outtext(" ╟───┼───┼───┼───┼───┼───╢");
  789. _settextposition(9,10);
  790. _outtext(" ║   │   │   │   │   │   ║");
  791. _settextposition(10,10);
  792. _outtext(" ╟───┼───┼───┼───┼───┼───╢             ╒═══╕      ");
  793. _settextposition(11,10);
  794. _outtext(" ║   │   │   │   │   │   ║             │   │      ");
  795. _settextposition(12,10);
  796. _outtext(" ╟───┼───┼───┼───┼───┼───╢      ╔══════╧═══╧══════╗ ");
  797. _settextposition(13,10);
  798. _outtext(" ║   │   │   │   │   │   ║      ║ ███ ███ ███ ███ ║ ");
  799. _settextposition(14,10);
  800. _outtext(" ╟───┼───┼───┼───┼───┼───╢      ║ █ █ █ █ █ █ █ █ ║ ");
  801. _settextposition(15,10);
  802. _outtext(" ║   │   │   │   │   │   ║      ║ ███ ███ ███ ███ ║ ");
  803. _settextposition(16,10);
  804. _outtext(" ╟───┼───┼───┼───┼───┼───╢      ╚═════════════════╝ ");
  805. _settextposition(17,10);
  806. _outtext(" ║   │   │   │   │   │   ║          Spielzug: 0 ");
  807. _settextposition(18,10);
  808. _outtext(" ╚═══╧═══╧═══╧═══╧═══╧═══╝");
  809.  
  810. spielfeld();
  811. wer_beginnt();
  812.  
  813. _settextcolor(MENSCH);
  814. _settextposition(7,40);
  815. _outtext("Ihr Zug :  -              ");
  816. }
  817.  
  818. /*----------------------------------------------------------------*/
  819.  
  820. int neues_spiel()
  821. {
  822. int retcode;
  823. char c;
  824.  _settextposition(8,39);
  825.  _outtext(" Noch ein Spiel (j/n)?");
  826.  c = (char)getche();
  827.  if ( c == 'j' || c == 'J' )
  828.       retcode = TRUE;
  829.  else retcode = FALSE;
  830.  
  831.  _settextposition(8,40);
  832.  _outtext("                     ");
  833.  
  834. return retcode;
  835. }
  836.  
  837. /*----------------------------------------------------------------*/
  838.  
  839. int spielende()
  840. {
  841. int x, y, Spieler_1 = 0, Spieler_2 = 0, retcode = FALSE;
  842.  
  843.  for ( x = 0; x <= 5; x++ )
  844.  {
  845.   for ( y = 0; y <= 5; y++ )
  846.   {
  847.    if ( Spieler[x][y] == COMPUTER && Zug_Anzahl > 2 )
  848.     Spieler_1 = COMPUTER;
  849.  
  850.    if ( Spieler[x][y] == MENSCH && Zug_Anzahl > 2 )
  851.     Spieler_2 = MENSCH;
  852.   }
  853.  }
  854.  
  855. Spieler_2 = Spieler_1 + Spieler_2;
  856.  
  857. if ( Spieler_2 == COMPUTER )
  858.     {
  859.      retcode = TRUE;
  860.     _settextcolor(COMPUTER);
  861.     _settextposition(7,39);
  862.     _outtext(" SIE HABEN VERLOREN!       ");
  863.    }
  864. else if ( Spieler_2 == MENSCH )
  865.      {
  866.       retcode = TRUE;
  867.       _settextcolor(MENSCH);
  868.       _settextposition(7,39);
  869.       _outtext(" SIE HABEN GEWONNEN!        ");
  870.      }
  871. return retcode;
  872. }
  873.  
  874. /*----------------------------------------------------------------*/
  875.  
  876. sprengen()
  877. {
  878. int x, y;
  879. int max_wert[6][6] = {
  880.              { 1, 2, 2, 2, 2, 1 },
  881.              { 2, 3, 3, 3, 3, 2 },
  882.              { 2, 3, 3, 3, 3, 2 },
  883.              { 2, 3, 3, 3, 3, 2 },
  884.              { 2, 3, 3, 3, 3, 2 },
  885.              { 1, 2, 2, 2, 2, 1 }};
  886.  
  887. spielfeld();  /* Vor der Sprengung */
  888.  
  889. do {
  890.  rumsbums = FALSE;
  891.  for (x = 0; x <= 5; x++) {
  892.   for (y = 0; y <= 5; y++) {
  893.    if ( Feld[x][y] > max_wert[x][y] )
  894.    {
  895.  
  896.     _settextcolor(3);
  897.     _settextposition(7,39);
  898.     _outtext(">>  ES WIRD GESPRENGT!  <<    ");
  899.  
  900.     _settextposition(7 + y * 2, 13 + x * 4);
  901.     printf("%d",Feld[x][y]);
  902.     _settextposition(7 + y * 2, 13 + x * 4);
  903.  
  904.     pause(350);
  905.     _settextposition(7 + y * 2, 13 + x * 4);
  906.     printf(" ");
  907.     _settextposition(7 + y * 2, 13 + x * 4);
  908.  
  909.     pause(350);
  910.     _settextposition(7 + y * 2, 13 + x * 4);
  911.     printf("%d",Feld[x][y]);
  912.     _settextposition(7 + y * 2, 13 + x * 4);
  913.  
  914.     pause(350);
  915.     _settextposition(7 + y * 2, 13 + x * 4);
  916.     printf(" ");
  917.     _settextposition(7 + y * 2, 13 + x * 4);
  918.  
  919.     pause(350);
  920.  
  921.  
  922. /*... Die 4 Eckpunke ......................................*/
  923.  
  924.      if ( max_wert[x][y] == 1 )
  925.     {
  926.           if ( x == 0 && y == 0 )
  927.          {
  928.            Feld[x][y] -= 2;
  929.  
  930.            if (Feld[x][y] == 0)
  931.                Spieler[x][y] = 0;
  932.  
  933.            Feld[x+1][y]++;
  934.            Spieler[x+1][y] = Aktueller_Spieler;
  935.  
  936.            Feld[x][y+1]++;
  937.            Spieler[x][y+1] = Aktueller_Spieler;
  938.  
  939.            spielfeld();
  940.          }
  941.  
  942.            else  if ( x == 5 && y == 0 )
  943.          {
  944.            Feld[x][y] -= 2;
  945.  
  946.            if ( Feld[x][y] == 0 )
  947.             Spieler[x][y] = 0;
  948.  
  949.            Feld[x-1][y]++;
  950.            Spieler[x-1][y] = Aktueller_Spieler;
  951.  
  952.            Feld[x][y+1]++;
  953.            Spieler[x][y+1] = Aktueller_Spieler;
  954.  
  955.            spielfeld();
  956.          }
  957.  
  958.            else  if ( x == 0 && y == 5 )
  959.          {
  960.            Feld[x][y] -= 2;
  961.  
  962.            if (Feld[x][y] == 0)
  963.                Spieler[x][y] = 0;
  964.  
  965.            Feld[x+1][y]++;
  966.            Spieler[x+1][y] = Aktueller_Spieler;
  967.  
  968.            Feld[x][y-1]++;
  969.            Spieler[x][y-1] = Aktueller_Spieler;
  970.  
  971.            spielfeld();
  972.          }
  973.  
  974.            else  if ( x == 5 && y == 5 )
  975.          {
  976.            Feld[x][y] -= 2;
  977.  
  978.            if (Feld[x][y] == 0)
  979.                Spieler[x][y] = 0;
  980.  
  981.  
  982.            Feld[x-1][y]++;
  983.            Spieler[x-1][y] = Aktueller_Spieler;
  984.  
  985.            Feld[x][y-1]++;
  986.            Spieler[x][y-1] = Aktueller_Spieler;
  987.  
  988.            spielfeld();
  989.          }
  990.     }
  991. /*...... Ende 4 Eckpunkte, Berechnung der Seiten ..........*/
  992.  
  993.     else if ( max_wert[x][y] == 2 )
  994.     {
  995.  
  996.       if ( y == 0 )
  997.           {
  998.            Feld[x][y] -= 3;
  999.  
  1000.            if (Feld[x][y] == 0)
  1001.            Spieler[x][y] = 0;
  1002.  
  1003.            Feld[x+1][y]++;
  1004.            Spieler[x+1][y] = Aktueller_Spieler;
  1005.  
  1006.            Feld[x-1][y]++;
  1007.            Spieler[x-1][y] = Aktueller_Spieler;
  1008.  
  1009.            Feld[x][y+1]++;
  1010.            Spieler[x][y+1] = Aktueller_Spieler;
  1011.  
  1012.            spielfeld();
  1013.            }
  1014.  
  1015.       else if ( y == 5 )
  1016.           {
  1017.            Feld[x][y] -= 3;
  1018.  
  1019.            if (Feld[x][y] == 0)
  1020.            Spieler[x][y] = 0;
  1021.  
  1022.            Feld[x+1][y]++;
  1023.            Spieler[x+1][y] = Aktueller_Spieler;
  1024.  
  1025.            Feld[x-1][y]++;
  1026.            Spieler[x-1][y] = Aktueller_Spieler;
  1027.  
  1028.            Feld[x][y-1]++;
  1029.            Spieler[x][y-1] = Aktueller_Spieler;
  1030.  
  1031.            spielfeld();
  1032.            }
  1033.  
  1034.  
  1035.       else if ( x == 0 )
  1036.           {
  1037.            Feld[x][y] -= 3;
  1038.  
  1039.            if (Feld[x][y] == 0)
  1040.            Spieler[x][y] = 0;
  1041.  
  1042.            Feld[x][y-1]++;
  1043.            Spieler[x][y-1] = Aktueller_Spieler;
  1044.  
  1045.            Feld[x][y+1]++;
  1046.            Spieler[x][y+1] = Aktueller_Spieler;
  1047.  
  1048.            Feld[x+1][y]++;
  1049.            Spieler[x+1][y] = Aktueller_Spieler;
  1050.  
  1051.            spielfeld();
  1052.            }
  1053.  
  1054.       else if ( x == 5 )
  1055.           {
  1056.            Feld[x][y] -= 3;
  1057.  
  1058.            if (Feld[x][y] == 0)
  1059.            Spieler[x][y] = 0;
  1060.  
  1061.            Feld[x][y-1]++;
  1062.            Spieler[x][y-1] = Aktueller_Spieler;
  1063.  
  1064.            Feld[x][y+1]++;
  1065.            Spieler[x][y+1] = Aktueller_Spieler;
  1066.  
  1067.            Feld[x-1][y]++;
  1068.            Spieler[x-1][y] = Aktueller_Spieler;
  1069.  
  1070.            spielfeld();
  1071.            }
  1072.      }
  1073.  
  1074. /*...... Ende der Seiten, Berechnung komplettes Mittelfeld.*/
  1075.  
  1076.      else if ( max_wert[x][y] == 3 )
  1077.           {
  1078.            Feld[x][y] -= 4;
  1079.  
  1080.            if (Feld[x][y] == 0)
  1081.            Spieler[x][y] = 0;
  1082.  
  1083.            Feld[x][y-1]++;
  1084.            Spieler[x][y-1] = Aktueller_Spieler;
  1085.  
  1086.            Feld[x][y+1]++;
  1087.            Spieler[x][y+1] = Aktueller_Spieler;
  1088.  
  1089.            Feld[x-1][y]++;
  1090.            Spieler[x-1][y] = Aktueller_Spieler;
  1091.  
  1092.            Feld[x+1][y]++;
  1093.            Spieler[x+1][y] = Aktueller_Spieler;
  1094.  
  1095.            spielfeld();
  1096.           }
  1097. /*.........................................................*/
  1098.    y = 6;
  1099.    rumsbums = TRUE;
  1100.    }
  1101.   } /* Ende innere FOR-Schleife  */
  1102.  } /* Ende äußere FOR-Schleife */
  1103.  
  1104.  } while ( rumsbums == TRUE && !spielende() ); /* weiter sprengen?*/
  1105. }
  1106. /*----------------------------------------------------------------*/
  1107.  
  1108. void main()
  1109. {
  1110. int i;
  1111. srand(1);  /* Zufallszahlen Generator initialisieren */
  1112. start:
  1113.  initialisieren();
  1114.  feld_zeichnen();
  1115.  
  1116.  if ( Aktueller_Spieler == COMPUTER )
  1117.      {
  1118.       computerzug();
  1119.       sprengen();
  1120.      }
  1121.  
  1122.  while ( !spielende() )
  1123.  {
  1124.   zug_eingeben();
  1125.   sprengen();
  1126.   if ( !spielende() )
  1127.      {
  1128.        computerzug();
  1129.        spielfeld();
  1130.        sprengen();
  1131.   }
  1132.  }
  1133.  
  1134. if ( neues_spiel() == TRUE )
  1135.      goto start;
  1136.  
  1137. _clearscreen( _GCLEARSCREEN);  /* Programm beenden und Bild löschen */
  1138. }
  1139. /*----------------- ENDE VON BESTRAFE.C ---------------------------*/
  1140.