home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / 1989 / 07 / beilage / wdreh.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-05-10  |  10.5 KB  |  373 lines
  1. /* -------------------------------------------- */
  2. /*                 WDREH.C                      */
  3. /*       (C) 1989 TOOLBOX & Alf Dengler         */
  4. /*         Compiler: Microsoft Quick C          */
  5. /* -------------------------------------------- */
  6. #include <stdio.h>     /* standard input output */
  7. #include <graph.h>     /* graphics include file */
  8. #include <ctype.h>
  9. #include <conio.h>
  10. #include <stdlib.h>
  11. #include <time.h>
  12. #include <string.h>
  13. #define DREH 12     /* Anzahl Drehmöglichkeiten */
  14. #define WDIM 3     /* Seitenlänge Würfelquadrat */
  15. #define WZAHL 9       /* Maximale Anzahl Würfel */
  16. #define MAX_ZUF 50    /* Maximale Drehungen zu  */
  17.               /* Beginn des Spiels      */
  18.  
  19. /* Variablenbedeutungen :                       */
  20. /*   dzahl    : Erwünschte Zahl Würfeldrehungen */
  21. /* m[WZAHL][6]: Spielfeldmatrix m               */
  22. /* erg[WZAHL] : Ergebnisvektor erg              */
  23. /*  vorbel[6] : Vektor zum Vorbelegen von m     */
  24. /*       punkt: benötigte Drehungen zum Wieder- */
  25. /*              herstellen des Spielfelds       */
  26. /* ranval[MAX_ZUF] : Die jeweilige Nummer der   */
  27. /*                   Zufallsverdrehung          */
  28. /* (1...12) wird im Vektor ranval abgespeichert */
  29.  
  30. char dreh_bed, strein[3];
  31. char ende[]  = "stop", name[81];
  32. char kontr[] = "123456789abc";
  33. char zuege[DREH][3]= { "L1","L2","L3","R1","R2",
  34.                "R3","O1","O2","O3","U1",
  35.                "U2","U3" };
  36. int dzahl, punkt, ranval[MAX_ZUF], richtig;
  37. int m[WZAHL][6],  erg[WZAHL];
  38. int vorbel[6] = { 1,2,3,4,5,6 };
  39.  
  40. /* Notwendige Strings zur Darstellung           */
  41. /* des Spielfelds und der Fenster               */
  42.  
  43. char ol[] = "╔", or[] = "╗", ml[] = "╠";
  44. char mr[] = "╣", ul[] = "╚", ur[] = "╝";
  45. char vert[]="║", ou[121], zeil_79[80];
  46. char horiz[] =
  47. "═══════════════════════════════════════════════";
  48. char sfeld_1[]=
  49. "╠══════╬═══╦═══╦═══╣",sfeld_2[]="║   ║   ║";
  50. char sfeld_3[]=
  51. "╠═══╬═══╬═══╣",sfeld_4[]="╩═══╩═══╩";
  52.  
  53. main()
  54. {
  55. int equal, zustart, horiz_len;
  56. long sekunden;
  57.  
  58.   horiz_len = strlen(horiz);
  59.   strncpy(ou,horiz,horiz_len);
  60.   strncat(ou,horiz,50);
  61.  
  62. /* Starten des Zufallsgenerators mit einer      */
  63. /*  Zufallszahl mit Hilfe der Zeitfunktion time */
  64.   time(&sekunden);
  65.   zustart = sekunden%1000;
  66.   srand(zustart);
  67.  
  68.   vorbeleg();
  69. /* Vorbelegen der Spielfeldmatrix m             */
  70.  
  71.   _setvideomode (_DEFAULTMODE);
  72. /* Voreingestellten Bildschirmmodus wählen      */
  73.  
  74.   titelbild();
  75. /* Programmname und Copyright am Bildschirm     */
  76.  
  77.   equal = 1;
  78.   while(equal != 0)
  79.   {
  80.     _clearscreen(_GCLEARSCREEN);
  81.             /*     Bildschirmaufbau     */
  82.     tfenster(1,1,25,79);
  83.     m_fzeil(3,1,79);
  84.     m_fzeil(19,1,79);
  85.     _settextposition(2,18);
  86.     printf(" W Ü R F E L D R E H ");
  87.     beschr();
  88.     _settextposition(10,10);
  89.     printf("Wie heißen Sie ");
  90.     printf("stop<ENTER> für Ende)?");
  91.     _settextposition(14,10);
  92.     gets(name);
  93.     _settextwindow(4,2,18,78);
  94.     _clearscreen(_GWINDOW);
  95.     _settextwindow(1,1,25,80);
  96.     equal = strcmpi(name,ende);
  97.      /* Test auf Programmende  (name=stop)  */
  98.     if(equal == 0)
  99.     {
  100.       _setvideomode(_DEFAULTMODE);
  101.         /* Alten Bildschirmmodus herstellen */
  102.       exit(0);
  103.     }
  104.     feldaufbau();   /*  Aufbau des Spielfeldes  */
  105.     spielfeld();
  106.     verdreh();
  107.     spielfeld();
  108.     dialog();
  109.     ergeb();
  110.     vorbeleg();
  111.   }
  112. }
  113.  
  114. int verdreh() {
  115. /*  Gewünschtes Umordnen der Spielfeldmatrix m  */
  116. int i;
  117. char zstring[80];
  118.  
  119.   dzahl = 0;
  120.   while(dzahl < 1) {
  121.        /*  Ermitteln von dzahl (1 ... MAX_ZUF) */
  122.     tfenster(9,33,15,75);
  123.     _settextwindow(11,37,14,73);
  124.     _clearscreen(_GWINDOW);
  125.     _outtext("Wie viele Umordnungen \n");
  126.     _outtext("sind erwünscht (1 ... 50) :  ");
  127.     _displaycursor(_GCURSORON);
  128.     gets(zstring);
  129.     dzahl = atoi(zstring);
  130.     _displaycursor(_GCURSOROFF);
  131.     if(dzahl > MAX_ZUF) dzahl = MAX_ZUF;
  132.     if(dzahl < 0) dzahl = 0;
  133.          /*  dzahl kann nicht negativ sein  */
  134.     _settextwindow(9,33,15,75);
  135.     _clearscreen(_GWINDOW);
  136.     _settextwindow(1,1,25,80);
  137.   }
  138.  
  139. /* Erzeugen der Zufallszahlen und Ändern        */
  140. /* der Belegung der Spielfeldmatrix m[WZAHL][6] */
  141.   for (i = 0; i < dzahl; i++) {
  142.     ranval[i] = rand()%DREH + 1; };
  143.   for (i = 0; i < dzahl; i++) {
  144.     dreh_bed = kontr[ranval[i] - 1];
  145.     drehung(); };
  146. }
  147.  
  148. int dialog() {
  149.   /* Dialog zur Erstellung der Ausgangsbelegung */
  150. int i, num;
  151.  
  152.   punkt = 0;  richtig = 0;
  153.   while(richtig == 0) {
  154.     tfenster(9,35,14,68);
  155.     _settextwindow(11,40,13,66);
  156.     _outtext("Eingabe der Drehung : ");
  157.     gets(strein);
  158.     _clearscreen(_GWINDOW);
  159.     for (i = 0; i < DREH; i++) {
  160.       num = strnicmp(strein, zuege[i], 2);
  161.       if (num == 0) {
  162.     dreh_bed = kontr[i];
  163.     _settextwindow(1,1,25,80);
  164.     drehung();
  165.     spielfeld();
  166.     punkt++;
  167.     break; }
  168.     }
  169.     _settextwindow(9,35,16,76);
  170.     _clearscreen(_GWINDOW);
  171.     _settextwindow(1,1,25,80);
  172.   }
  173. }
  174.  
  175. int drehung() {
  176. /* Umordnung der Spielfeldmatrix m und Prüfung, */
  177. /* ob die Ausgangsbelegung wieder erreicht ist. */
  178. int hilf, i, sp, zl;
  179.  
  180.   switch(dreh_bed) {
  181.     case'1':
  182.     case'4': sp = 0;  break;
  183.     case'2':
  184.     case'5': sp = 1;  break;
  185.     case'3':
  186.     case'6': sp = 2;  break;
  187.     case'7':
  188.     case'a': zl = 0;  break;
  189.     case'8':
  190.     case'b': zl = 3;  break;
  191.     case'9':
  192.     case'c': zl = 6;  break;}
  193.  
  194.   switch(dreh_bed) {
  195.     case'1':
  196.     case'2':
  197.     case'3': for (i = 0; i < WDIM; i++) {
  198.            hilf = m[sp][5];
  199.            m[sp][5] = m[sp][1];
  200.            m[sp][1] = m[sp][0];
  201.            m[sp][0] = m[sp][4];
  202.            m[sp][4] = hilf;
  203.            sp += WDIM; }  break;
  204.     case'4':
  205.     case'5':
  206.     case'6': for (i = 0; i < WDIM; i++) {
  207.            hilf = m[sp][5];
  208.            m[sp][5] = m[sp][4];
  209.            m[sp][4] = m[sp][0];
  210.            m[sp][0] = m[sp][1];
  211.            m[sp][1] = hilf;
  212.            sp += WDIM; }  break;
  213.     case'7':
  214.     case'8':
  215.     case'9': for (i = 0; i < WDIM; i++) {
  216.            hilf = m[zl][5];
  217.            m[zl][5] = m[zl][2];
  218.            m[zl][2] = m[zl][0];
  219.            m[zl][0] = m[zl][3];
  220.            m[zl][3] = hilf;
  221.            zl++; }  break;
  222.     case'a':
  223.     case'b':
  224.     case'c': for (i = 0; i < WDIM; i++) {
  225.            hilf = m[zl][5];
  226.            m[zl][5] = m[zl][3];
  227.            m[zl][3] = m[zl][0];
  228.            m[zl][0] = m[zl][2];
  229.            m[zl][2] = hilf;
  230.            zl++; };  break;
  231.   }
  232.  /*  Vergleich der Ergebnisvektorwerte erg[i]   */
  233.  /*  mit den Matrixwerten m[i][5] mit i=0 ... 5 */
  234.   hilf = 0;
  235.   for (i = 0; i < WZAHL; i++) {
  236.     if (erg[i] == m[i][5]) hilf++;}
  237.   if (hilf == WZAHL)  richtig++;
  238. }
  239.  
  240. int vorbeleg() {
  241. /* Vorbelegen der Spielfeldmatrix               */
  242. int i, j;
  243.  
  244.   for (i = 0; i < WZAHL; i++) {
  245.     for (j = 0; j < 6; j++) {
  246.       m[i][j] = vorbel[j]; }}
  247.   for (i = 0; i < WZAHL; i++) { erg[i] = 6; }
  248.          /* Belegen des Ergebnisvektors */
  249. }
  250.  
  251. int feldaufbau() {  /*  Aufbau des Spielfeldes  */
  252.       /*  Zeilen- und Spaltenbeschriftung   */
  253.   tfenster(7,10,16,29);
  254.   _settextposition(7,17);  printf("╦");
  255.   _settextposition(8,17);  printf("║S P A L T E");
  256.   _settextposition(9,17);  printf("║ 1   2   3");
  257.   _settextposition(11,12); printf("Z  1");
  258.   _settextposition(12,12); printf("E");
  259.   _settextposition(13,12); printf("I  2");
  260.   _settextposition(14,12); printf("L");
  261.   _settextposition(15,12); printf("E  3");
  262.        /*   Ziehen der Linien des Würfelfeldes  */
  263.   _settextposition(10,10); cputs(sfeld_1);
  264.   _settextposition(11,17); cputs(sfeld_2);
  265.   _settextposition(12,17); cputs(sfeld_3);
  266.   _settextposition(13,17); cputs(sfeld_2);
  267.   _settextposition(14,17); cputs(sfeld_3);
  268.   _settextposition(15,17); cputs(sfeld_2);
  269.   _settextposition(16,17); cputs(sfeld_4);
  270. }
  271.  
  272. int beschr() {
  273.      /*  Spielregeln im unteren Bildschirmteil  */
  274.   _settextposition(20,10);  printf("Mögliche ");
  275.   printf("Drehungen (jeweils um 90 Grad) :");
  276.   _settextposition(21,10);
  277.   printf("Spaltendrehung: L = Links  R = Rechts");
  278.   _settextposition(22,10);
  279.   printf("Zeilendrehung O = nach oben");
  280.   _settextposition(23,22);
  281.   printf("U = Drehung einer Zeile nach unten");
  282.   _settextposition(24,10);
  283.   printf("z.B.: O1=Zeile 1 um 90 Grad nach oben");
  284. }
  285.  
  286. int ergeb() {
  287.       /*  Ausgabe des Ergebnisses am Bildschirm */
  288. int hilf, hilf2, h3;
  289.   hilf = strlen(name);  h3 = 0;
  290.   tfenster(6,35,16,76);  m_fzeil(14,35,42);
  291.   if (hilf < 10) {
  292.     _settextposition(8,38);
  293.     printf("Ergebnisse des Spielers %s !",name);}
  294.   else {
  295.     hilf2 = 38 + (38 - hilf) / 2;  h3 = 7;
  296.     _settextposition(8,38+h3);
  297.     printf("Ergebnisse des Spielers");
  298.     _settextposition(9,hilf2);
  299.     printf("%s",name);  }
  300.   _settextposition(11,38+h3);
  301.   printf("Zahl der Umordnungen : %d ",dzahl);
  302.   _settextposition(12,38+h3);
  303.   printf("      Benötigte Züge : %d",punkt);
  304.   _settextposition(15,38);
  305.   printf("Bitte drücken Sie die <ENTER>-Taste");
  306.   getchar();
  307. }
  308.  
  309. int titelbild() {
  310.      /*   Titel am Bildschirm darstellen    */
  311.       /*  Aufforderung zum drücken einer Taste  */
  312.   tfenster(21,18,23,63);
  313.   _settextposition(22,21);
  314.   printf(" Bitte drücken Sie die <ENTER>-Taste!");
  315.   _settextposition(8,30);  printf(" WÜRFELDREH");
  316.   tfenster(6,25,12,55);    tfenster(5,22,13,58);
  317.   tfenster(3,18,15,62);
  318.   _settextposition(22,60);
  319.   while(!kbhit());         getch();
  320.   _clearscreen(_GCLEARSCREEN);
  321. }
  322.  
  323. int spielfeld() {
  324. /* Belegen des Spielfeldes mit den Würfelwerten */
  325. int spaltnr, zeilnr = 9, j, k, zaehler=0;
  326.   for (j = 0; j < WDIM; j++) {
  327.     zeilnr += 2;  spaltnr = 15;
  328.     for (k = 0; k < WDIM; k++) {
  329.       spaltnr += 4;
  330.       _settextposition(zeilnr,spaltnr);
  331.       printf("%d", m[zaehler][5]);  zaehler++;}
  332.   }
  333. }
  334.  
  335. int tfenster(lo_y, lo_x, ru_y, ru_x)
  336.          /*  Zeichnen eines Fensterrahmens  */
  337. int lo_x, lo_y, ru_x, ru_y;
  338. {
  339. char str_breit[85];
  340. int i,f_breite,f_hoehe;
  341.   f_breite = ru_x - lo_x + 1;
  342.   f_hoehe  = ru_y - lo_y + 1;
  343.   strncpy(str_breit, ol, 2);
  344.   strncat(str_breit, ou, f_breite - 2);
  345.   strncat(str_breit, or, 1);
  346.   _settextposition(lo_y, lo_x);
  347.   cputs(str_breit);
  348.   for (i = lo_y + 1; i < ru_y; i++) {
  349.     _settextposition(i, lo_x);
  350.     printf("%s", vert);
  351.     _settextposition(i, ru_x);
  352.     printf("%s", vert); }
  353.   strncpy(str_breit, ul, 2);
  354.   strncat(str_breit, ou, f_breite - 2);
  355.   strncat(str_breit, ur, 1);
  356.   _settextposition(ru_y, lo_x);
  357.   cputs(str_breit);
  358. }
  359.  
  360. int m_fzeil(l_y, l_x, m_len) int l_x, l_y, m_len;
  361.    /*  Zeichnen eines horiz. Fenstertrennteiles */
  362. {
  363. char str_breit[85];
  364.   strncpy(str_breit, ml, 2);
  365.   strncat(str_breit, ou, m_len - 2);
  366.   strncat(str_breit, mr, 1);
  367.   _settextposition(l_y, l_x);
  368.   cputs(str_breit);
  369. }
  370. /* -------------------------------------------- */
  371. /*              Ende von WDREH.C                */
  372.  
  373.