API tools faq
paste
Advertisement
Guest User

Minesweeper

a guest
Jun 24th, 2012
93
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 15.52 KB | None | 0 0
raw download clone embed print report
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4. #include <ctype.h>
  5.  
  6. #define SPALTEN 26
  7. #define ZEILEN 26
  8. #define GROSS_A 65
  9.  
  10. void feldAnzeigen(int feldberechnet[], int feldwerte[], size_t zeilen, size_t spalten);
  11. void feldAnzeigenEnde(int feld[], size_t zeilen, size_t spalten);
  12. void feldFuellen(int feld[], size_t zeilen, size_t spalten, int bomben);
  13. void feldBerechnen(int feld[], size_t zeilen, size_t spalten);
  14. void eingabefeld(int *xkord, int *ykord, size_t zeilen, size_t spalten);
  15. int pruefBombe(int feld[], size_t xkord, size_t ykord, size_t spalten);
  16. void feldAufdecken(int feldberechnet[], int feldwerte[], size_t zeilen, size_t spalten, size_t ykord, size_t xkord);
  17. void feldAufdeckenNullen(int feldberechnet[], int feldwerte[], size_t zeilen, size_t spalten, size_t xkord, size_t ykord);
  18. void feldUeberpruefen(int feldberechnet[], int feldwerte[], size_t zeilen, size_t spalten);
  19. int pruefGewinn(int feld[], size_t zeilen, size_t spalten, int bomben);
  20. int nochEinmal(void);
  21.  
  22. int main() {
  23.    
  24.     do{
  25.    
  26.     char eingabe[300], dummy1, dummy2;
  27.     int ok, zeilen = 25, spalten = 25, bomben = 1;
  28.    
  29.     printf("\nWillkommen beim Domi - Minesweeper!\n"
  30.            "Wieviele Spalten soll das Feld beinhalten? (max: %d)\n", SPALTEN);
  31.        
  32.     do {
  33.        
  34.         printf("--->");
  35.  
  36.         fgets(eingabe, 300, stdin);
  37.    
  38.         ok = sscanf(eingabe, "%d%c%c", &spalten, &dummy1, &dummy2);
  39.        
  40.         ok != 2 ? printf("Falsche Eingabe!\n") : ok;
  41.        
  42.         spalten > SPALTEN ? printf("Spaltenanzahl zu hoch!\n"): ok;
  43.        
  44.         spalten <= 1 ? printf("Spaltenanzahl zu gering!\n"): ok;
  45.    
  46.     }while(ok != 2 || spalten > SPALTEN || spalten <= 1);
  47.    
  48.     printf("Wieviele Zeilen soll das Feld beinhalten ? (max: %d)\n", ZEILEN);
  49.    
  50.     do {
  51.        
  52.         printf("--->");
  53.  
  54.         fgets(eingabe, 300, stdin);
  55.    
  56.         ok = sscanf(eingabe, "%d%c%c", &zeilen, &dummy1, &dummy2);
  57.        
  58.         ok != 2 ? printf("Falsche Eingabe!\n") : ok;
  59.        
  60.         zeilen > ZEILEN ? printf("Zeilenanzahl zu hoch!\n"): ok;
  61.        
  62.         zeilen <= 1 ? printf("Zeilenanzahl zu gering!\n"): ok;
  63.    
  64.     }while(ok != 2 || zeilen > ZEILEN || zeilen <= 1);
  65.    
  66.     printf("Wieviele Bomben soll das Feld beinhalten? (max: %d)\n", zeilen*spalten - 1);
  67.    
  68.     do {
  69.        
  70.         printf("--->");
  71.        
  72.         fgets(eingabe, 300, stdin);
  73.        
  74.         ok = sscanf(eingabe, "%d%c%c", &bomben, &dummy1, &dummy2);
  75.        
  76.         ok != 2 ? printf("Falsche Eingabe!\n") : ok;
  77.        
  78.         bomben > zeilen*spalten - 1 ? printf("Bombenanzahl zu hoch!\n") : ok;
  79.        
  80.         bomben < 1 ? printf("Bombenanzahl zu gering!\n") : ok;
  81.        
  82.     } while (bomben > zeilen*spalten - 1 || bomben < 1 || ok != 2);
  83.    
  84.     int *bombenfeld, i, j;
  85.    
  86.     bombenfeld = malloc(sizeof(int) * zeilen * spalten);
  87.    
  88.     for (j = 0; j < zeilen; j++) {
  89.        
  90.         for ( i = 0; i < spalten; i++){
  91.            
  92.             bombenfeld[j * spalten + i] = 0;
  93.            
  94.         }
  95.        
  96.     }
  97.    
  98.     feldFuellen(bombenfeld, zeilen, spalten, bomben);
  99.    
  100.     feldBerechnen(bombenfeld, zeilen, spalten);
  101.    
  102.     int *feldaufgedeckt;
  103.    
  104.     feldaufgedeckt = malloc(sizeof(int) * spalten * zeilen);
  105.    
  106.     for (j = 0; j < zeilen; j++) {
  107.        
  108.         for (i = 0; i < spalten; i++) {
  109.            
  110.             feldaufgedeckt[j * spalten + i] = 0;
  111.            
  112.         }
  113.        
  114.     }
  115.    
  116.     int xkord, ykord;
  117.    
  118.     do {
  119.        
  120.         feldAnzeigen(bombenfeld, feldaufgedeckt, zeilen, spalten);
  121.        
  122.         eingabefeld(&xkord, &ykord, zeilen, spalten);
  123.        
  124.         if(pruefBombe(bombenfeld, xkord, ykord, spalten)){
  125.            
  126.             break;
  127.            
  128.         }
  129.        
  130.         feldAufdecken(bombenfeld, feldaufgedeckt, zeilen, spalten, ykord, xkord);
  131.        
  132.         if(pruefGewinn(feldaufgedeckt, zeilen, spalten, bomben)){
  133.            
  134.             break;
  135.            
  136.         }
  137.        
  138.     } while (1);
  139.    
  140.     if(pruefGewinn(feldaufgedeckt, zeilen, spalten, bomben)){
  141.        
  142.         printf("\nGratuliere du hast Minesweeper durchgespielt :D\n");
  143.        
  144.     }
  145.     else {
  146.        
  147.         printf("\nBOOM!\n");
  148.        
  149.     }
  150.    
  151.     feldAnzeigenEnde(bombenfeld, zeilen, spalten);
  152.    
  153.     putchar('\n');
  154.    
  155.     free(bombenfeld);
  156.     free(feldaufgedeckt);
  157.        
  158.    
  159.     }while (nochEinmal());
  160.    
  161.     return 0;
  162.    
  163. }
  164.  
  165.  
  166. void feldAnzeigenEnde(int feld[], size_t zeilen, size_t spalten){
  167.    
  168.     unsigned int i, j;
  169.    
  170.     printf("\n   ");
  171.    
  172.     for (i = 0; i < spalten; i++) {
  173.        
  174.         printf(" %c", GROSS_A + i);
  175.        
  176.     }
  177.    
  178.     putchar('\n');
  179.    
  180.     for (i = 0; i < spalten + spalten + 4; i++) {
  181.        
  182.         putchar('*');
  183.        
  184.     }
  185.    
  186.     putchar('\n');
  187.    
  188.     for (j = 0; j < zeilen; j++) {
  189.        
  190.         printf("%2d ", j + 1);
  191.        
  192.         putchar('|');
  193.        
  194.         for (i = 0; i < spalten; i++) {
  195.            
  196.             if(feld[j * spalten + i] == -1){
  197.                
  198.                 printf("X|");
  199.                
  200.             }
  201.             else if(feld[j * spalten + i] == 0){
  202.                
  203.                 printf(" |");
  204.                        
  205.             }
  206.             else{
  207.                            
  208.                 printf("%d|", feld[j * spalten + i]);
  209.                                    
  210.             }
  211.            
  212.         }
  213.        
  214.         putchar('\n');
  215.        
  216.     }
  217.    
  218.     for (i = 0; i < spalten + spalten + 4; i++) {
  219.            
  220.         putchar('*');
  221.            
  222.     }
  223.    
  224. }
  225.  
  226. void feldFuellen(int feld[], size_t zeilen, size_t spalten, int bomben){
  227.    
  228.     srand(time(NULL));
  229.    
  230.     int i, bombenzeile, bombenspalte;
  231.    
  232.     for (i = 0; i < bomben;) {
  233.        
  234.         bombenzeile = rand() % zeilen;
  235.         bombenspalte = rand() % spalten;
  236.        
  237.         if(feld[bombenzeile * spalten + bombenspalte] == -1){
  238.            
  239.             continue;
  240.            
  241.         }
  242.         else if(feld[bombenzeile * spalten + bombenspalte] != -1){
  243.            
  244.             feld[bombenzeile * spalten + bombenspalte] = -1;
  245.             i++;
  246.            
  247.         }
  248.        
  249.     }
  250.    
  251. }
  252.  
  253. void feldBerechnen(int feld[], size_t zeilen, size_t spalten){
  254.    
  255.     int i, j, anzahl = 0;
  256.    
  257.     for (j = 0;(unsigned) j < zeilen; j++) {
  258.        
  259.         for (i = 0;(unsigned) i < spalten; i++) {
  260.            
  261.             if(feld[j * spalten + i] == -1){
  262.                
  263.                 continue;
  264.                
  265.             }
  266.            
  267.             if(i - 1 >= 0 && j - 1 >= 0){
  268.                
  269.                 if(feld[j * spalten + i - 1 - spalten] == -1){
  270.                    
  271.                     anzahl++;
  272.                    
  273.                 }
  274.                
  275.             }
  276.            
  277.             if(j - 1 >= 0){
  278.                
  279.                 if(feld[j * spalten + i - spalten] == -1){
  280.                    
  281.                     anzahl++;
  282.                    
  283.                 }
  284.                
  285.             }
  286.            
  287.             if(j - 1 >= 0 && (unsigned) i + 1 < spalten){
  288.                
  289.                 if(feld[j * spalten + i + 1 - spalten] == -1){
  290.                    
  291.                     anzahl++;
  292.                    
  293.                 }
  294.                
  295.             }
  296.            
  297.             if(i - 1 >= 0){
  298.                
  299.                 if(feld[j * spalten + i - 1] == -1){
  300.                    
  301.                     anzahl++;
  302.                    
  303.                 }
  304.                
  305.             }
  306.            
  307.             if((unsigned)i + 1 < spalten){
  308.                
  309.                 if(feld[j * spalten + i + 1] == -1){
  310.                    
  311.                     anzahl++;
  312.                    
  313.                 }
  314.                
  315.             }
  316.            
  317.             if((unsigned)j + 1 < zeilen && i - 1 >= 0){
  318.                
  319.                 if(feld[j * spalten + i - 1 + spalten] == -1){
  320.                    
  321.                     anzahl++;
  322.                    
  323.                 }
  324.                
  325.             }
  326.            
  327.             if((unsigned)j + 1 < zeilen){
  328.                
  329.                 if(feld[j * spalten + i + spalten] == -1){
  330.                    
  331.                     anzahl++;
  332.                    
  333.                 }
  334.                
  335.             }
  336.            
  337.             if((unsigned)j + 1 < zeilen && (unsigned)i + 1 < spalten){
  338.                
  339.                 if(feld[j * spalten + i + 1 + spalten] == -1){
  340.                    
  341.                    anzahl++;
  342.                    
  343.                 }
  344.                
  345.             }
  346.            
  347.             feld[j * spalten + i] = anzahl;
  348.             anzahl = 0;
  349.            
  350.         }
  351.        
  352.     }
  353.    
  354. }
  355.  
  356. void eingabefeld(int *xkord, int *ykord, size_t zeilen, size_t spalten){
  357.    
  358.     printf("\n\nGeben Sie das gewuenschte Feld ein (zB. A5)\n");
  359.    
  360.     int ok;
  361.     char eingabe[300], dummy1, dummy2, kordx;
  362.    
  363.     spalten = spalten + GROSS_A;
  364.    
  365.     do {
  366.        
  367.         printf("--->");
  368.        
  369.         fgets(eingabe, 300, stdin);
  370.        
  371.         ok = sscanf(eingabe, "%c%d%c%c", &kordx, ykord, &dummy1, &dummy2);
  372.        
  373.         kordx = toupper(kordx);
  374.        
  375.         if(ok != 3){
  376.            
  377.             printf("Falsche Eingabe!\n");
  378.            
  379.         }
  380.         else {
  381.        
  382.             !isupper(kordx) ? printf("Kein Spaltenbuchstabe angegeben!\n") : ok;
  383.        
  384.             (unsigned)kordx >= spalten ? printf("Zu grosse Spalte angegeben!\n") : ok;
  385.        
  386.             (unsigned)*ykord > zeilen ? printf("Zu grosse Zeile angegeben!\n") : ok;
  387.        
  388.         }
  389.        
  390.     } while (ok != 3 || !isupper(kordx) || (unsigned)kordx >= spalten || (unsigned)*ykord > zeilen);
  391.    
  392.     *xkord = kordx - GROSS_A;
  393.     (*ykord)--;
  394.    
  395. }
  396.  
  397.  
  398. int pruefBombe(int feld[], size_t xkord, size_t ykord, size_t spalten){
  399.    
  400.     if(feld[ykord * spalten + xkord] == -1){
  401.        
  402.         return 1;
  403.        
  404.     }
  405.    
  406.     return 0;
  407.    
  408. }
  409.  
  410.  
  411. void feldAnzeigen(int feldberechnet[], int feldwerte[], size_t zeilen, size_t spalten){
  412.    
  413.     unsigned int i, j;
  414.    
  415.     printf("\n   ");
  416.    
  417.     for (i = 0; i < spalten; i++) {
  418.        
  419.         printf(" %c", GROSS_A + i);
  420.        
  421.     }
  422.    
  423.     putchar('\n');
  424.    
  425.     for (i = 0; i < spalten + spalten + 4; i++) {
  426.        
  427.         putchar('*');
  428.        
  429.     }
  430.    
  431.     putchar('\n');
  432.    
  433.     for (j = 0; j < zeilen; j++) {
  434.        
  435.         printf("%2d ", j + 1);
  436.        
  437.         putchar('|');
  438.        
  439.         for (i = 0; i < spalten; i++) {
  440.            
  441.             if(feldwerte[j * spalten + i] == 1){
  442.                
  443.                 printf("%d|", feldberechnet[j * spalten + i]);
  444.                
  445.             }
  446.             else{
  447.                
  448.                 printf(" |");
  449.                        
  450.             }
  451.            
  452.         }
  453.        
  454.         putchar('\n');
  455.        
  456.     }
  457.    
  458.     for (i = 0; i < spalten + spalten + 4; i++) {
  459.            
  460.         putchar('*');
  461.            
  462.     }
  463.    
  464. }
  465.  
  466.  
  467. void feldAufdecken(int feldberechnet[], int feldwerte[], size_t zeilen, size_t spalten, size_t ykord, size_t xkord){
  468.    
  469.     if(feldberechnet[ykord * spalten + xkord] == 0){
  470.        
  471.         feldwerte[ykord * spalten + xkord] = 1;
  472.        
  473.         feldAufdeckenNullen(feldberechnet, feldwerte, zeilen, spalten, xkord, ykord);
  474.        
  475.         feldUeberpruefen(feldberechnet, feldwerte, zeilen, spalten);
  476.        
  477.     }else {
  478.        
  479.         feldwerte[ykord * spalten + xkord] = 1;
  480.        
  481.     }
  482.    
  483. }
  484.  
  485.  
  486. void feldAufdeckenNullen(int feldberechnet[], int feldwerte[], size_t zeilen, size_t spalten, size_t xkord, size_t ykord){
  487.    
  488.     int i = xkord, j = ykord;
  489.    
  490.     if(i - 1 >= 0 && j - 1 >= 0){
  491.        
  492.         if(feldberechnet[j * spalten + i - 1 - spalten] != 0){
  493.            
  494.             feldwerte[j * spalten + i - 1 - spalten] = 1;
  495.        
  496.         }
  497.                
  498.     }
  499.            
  500.     if(j - 1 >= 0){
  501.                
  502.         feldwerte[j * spalten + i - spalten] = 1;
  503.                
  504.     }
  505.            
  506.     if(j - 1 >= 0 && (unsigned)i + 1 < spalten){
  507.        
  508.         if(feldberechnet[j * spalten + i + 1 - spalten] != 0){
  509.            
  510.             feldwerte[j * spalten + i + 1 - spalten] = 1;
  511.        
  512.         }
  513.     }
  514.            
  515.     if(i - 1 >= 0){
  516.                
  517.         feldwerte[j * spalten + i - 1] = 1;
  518.                
  519.     }
  520.            
  521.     if((unsigned)i + 1 < spalten){
  522.                
  523.         feldwerte[j * spalten + i + 1] = 1;
  524.                
  525.     }
  526.            
  527.     if((unsigned)j + 1 < zeilen && i - 1 >= 0){
  528.        
  529.         if(feldberechnet[j * spalten + i - 1 + spalten] != 0){
  530.        
  531.             feldwerte[j * spalten + i - 1 + spalten] = 1;
  532.        
  533.         }
  534.        
  535.     }
  536.            
  537.     if((unsigned)j + 1 < zeilen){
  538.                
  539.         feldwerte[j * spalten + i + spalten] = 1;
  540.                
  541.     }
  542.            
  543.     if((unsigned)j + 1 < zeilen && (unsigned)i + 1 < spalten){
  544.        
  545.         if(feldberechnet[j * spalten + i + 1 + spalten] != 0){
  546.            
  547.             feldwerte[j * spalten + i + 1 + spalten] = 1;
  548.        
  549.         }
  550.            
  551.     }
  552.    
  553. }
  554.  
  555. void feldUeberpruefen(int feldberechnet[], int feldwerte[], size_t zeilen, size_t spalten){
  556.    
  557.     int test = 0, i, j, anzahl;
  558.    
  559.     for (j = 0;(unsigned) j < zeilen; j++) {
  560.        
  561.         for (i = 0;(unsigned) i < spalten; i++) {
  562.            
  563.             if(feldwerte[j * spalten + i] == 1 && feldberechnet[j * spalten + i] == 0){
  564.                
  565.                 test++;
  566.                 feldAufdeckenNullen(feldberechnet, feldwerte, zeilen, spalten, i, j);
  567.                
  568.                
  569.             }
  570.            
  571.         }
  572.        
  573.     }
  574.    
  575.     do {
  576.        
  577.         anzahl = 0;
  578.        
  579.         for (j = 0;(unsigned) j < zeilen; j++) {
  580.        
  581.             for (i = 0;(unsigned) i < spalten; i++) {
  582.            
  583.                 if(feldwerte[j * spalten + i] == 1 && feldberechnet[j * spalten + i] == 0){
  584.                
  585.                     anzahl++;
  586.                     feldAufdeckenNullen(feldberechnet, feldwerte, zeilen, spalten, i, j);
  587.                
  588.                
  589.                 }
  590.            
  591.             }
  592.        
  593.         }
  594.        
  595.         if(anzahl == test){
  596.            
  597.             break;
  598.            
  599.         }
  600.         else {
  601.            
  602.             test = anzahl;
  603.            
  604.         }
  605.        
  606.     } while (1);
  607.    
  608. }
  609.  
  610. int pruefGewinn(int feld[], size_t zeilen, size_t spalten, int bomben){
  611.    
  612.     size_t i, j, anzahl = 0;
  613.    
  614.     for (j = 0; j < zeilen; j++) {
  615.        
  616.         for (i = 0; i < spalten; i++) {
  617.            
  618.             if(feld[j * spalten + i] == 0){
  619.                
  620.                 anzahl++;
  621.                
  622.             }
  623.            
  624.         }
  625.        
  626.     }
  627.    
  628.     if(anzahl == (unsigned)bomben){
  629.        
  630.         return 1;
  631.        
  632.     }
  633.    
  634.     return 0;
  635.    
  636. }
  637.  
  638. int nochEinmal(void){
  639.    
  640.     char eingabe[300], befehl, dummy1, dummy2;
  641.     int ok;
  642.    
  643.     printf("\nWollen sie nocheinmal spielen? (j/n)");
  644.    
  645.     do {
  646.        
  647.         printf("\n--->");
  648.        
  649.         fgets(eingabe, 300, stdin);
  650.        
  651.         ok = sscanf(eingabe, "%c%c%c", &befehl, &dummy1, &dummy2);
  652.        
  653.     } while (ok != 2 || dummy1 != '\n' || !(befehl == 'j' || befehl == 'n'));
  654.    
  655.     return befehl == 'j' ? 1 : 0;
  656.    
  657. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!