API tools faq
paste
Advertisement
Guest User

Minesweeper

a guest
Jun 22nd, 2012
42
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 11.67 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 ZEILEN 26
  7. #define SPALTEN 26
  8. #define GROSS_A 65
  9.  
  10. void feldAnzeigen(int feldberechnet[ZEILEN][SPALTEN], int feldwerte[ZEILEN][SPALTEN], int zeilen, int spalten);
  11. void feldAnzeigenEnde(int feld[ZEILEN][SPALTEN], int zeilen, int spalten);
  12. void feldFuellen(int feld[ZEILEN][SPALTEN], size_t zeilen, size_t spalten, int bomben);
  13. void feldBerechnen(int feld[ZEILEN][SPALTEN], int zeilen, int spalten);
  14. void eingabefeld(int *xkord, int *ykord, int zeilen, int spalten);
  15. int pruefBombe(int feld[ZEILEN][SPALTEN], int xkord, int ykord);
  16. //void feldAufdecken(int feldberechnet[ZEILEN][SPALTEN], int feldwerte[ZEILEN][SPALTEN], int xkord, int ykord, int zeilen, int spalten);
  17. //int feldAufdeckenNullen(int feldberechnet[ZEILEN][SPALTEN], int feldwerte[ZEILEN][SPALTEN], int zeilen, int spalten);
  18.  
  19. int main() {
  20.    
  21.     char eingabe[300], dummy1, dummy2;
  22.     int ok, zeilen = 25, spalten = 25, bomben = 1;
  23.    
  24.     printf("\nWillkommen bei Minesweeper!\n"
  25.            "Wieviele Spalten soll das Feld beinhalten? (max: %d)\n", SPALTEN);
  26.        
  27.     do {
  28.        
  29.         printf("--->");
  30.  
  31.         fgets(eingabe, 300, stdin);
  32.    
  33.         ok = sscanf(eingabe, "%d%c%c", &spalten, &dummy1, &dummy2);
  34.        
  35.         ok != 2 ? printf("Falsche Eingabe!\n") : ok;
  36.        
  37.         spalten > SPALTEN ? printf("Spaltenanzahl zu hoch!\n"): ok;
  38.        
  39.         spalten < 1 ? printf("Spaltenanzahl zu gering!\n"): ok;
  40.    
  41.     }while(ok != 2 || spalten > SPALTEN || spalten < 1);
  42.    
  43.     printf("Wieviele Zeilen soll das Feld beinhalten ? (max: %d)\n", ZEILEN);
  44.    
  45.     do {
  46.        
  47.         printf("--->");
  48.  
  49.         fgets(eingabe, 300, stdin);
  50.    
  51.         ok = sscanf(eingabe, "%d%c%c", &zeilen, &dummy1, &dummy2);
  52.        
  53.         ok != 2 ? printf("Falsche Eingabe!\n") : ok;
  54.        
  55.         zeilen > ZEILEN ? printf("Zeilenanzahl zu hoch!\n"): ok;
  56.        
  57.         zeilen < 1 ? printf("Zeilenanzahl zu gering!\n"): ok;
  58.    
  59.     }while(ok != 2 || zeilen > ZEILEN || zeilen < 1);
  60.    
  61.     printf("Wieviele Bomben soll das Feld beinhalten? (max: %d)\n", zeilen*spalten);
  62.    
  63.     do {
  64.        
  65.         printf("--->");
  66.        
  67.         fgets(eingabe, 300, stdin);
  68.        
  69.         ok = sscanf(eingabe, "%d%c%c", &bomben, &dummy1, &dummy2);
  70.        
  71.         ok != 2 ? printf("Falsche Eingabe!\n") : ok;
  72.        
  73.         bomben > zeilen*spalten ? printf("Bombenanzahl zu hoch!\n") : ok;
  74.        
  75.         bomben < 1 ? printf("Bombenanzahl zu gering!\n") : ok;
  76.        
  77.     } while (bomben > zeilen*spalten || bomben < 1 || ok != 2);
  78.    
  79.     int bombenfeld[zeilen][spalten], i, j;
  80.    
  81.     for (j = 0; j < zeilen; j++) {
  82.        
  83.         for ( i = 0; i < spalten; i++){
  84.            
  85.             bombenfeld[j][i] = 0;
  86.            
  87.         }
  88.        
  89.     }
  90.    
  91.     feldFuellen(bombenfeld, zeilen, spalten, bomben);
  92.    
  93.     feldBerechnen(bombenfeld, zeilen, spalten);
  94.    
  95.     /*int feldaufgedeckt[zeilen][spalten], j, i;
  96.    
  97.     for (j = 0; j < zeilen; j++) {
  98.        
  99.         for (i = 0; i < spalten; i++) {
  100.            
  101.             feldaufgedeckt[j][i] = 0;
  102.            
  103.         }
  104.        
  105.     }
  106.    
  107.     int xkord, ykord;
  108.     */
  109.    
  110.     feldAnzeigenEnde(bombenfeld, zeilen, spalten);
  111.    
  112.     /*do {
  113.        
  114.         feldAnzeigen(bombenfeld, feldaufgedeckt, zeilen, spalten);
  115.        
  116.         eingabefeld(&xkord, &ykord, zeilen, spalten);
  117.        
  118.         if(pruefBombe(bombenfeld, xkord, ykord)){
  119.            
  120.             break;
  121.            
  122.         }
  123.        
  124.     } while (1);
  125.    
  126.     printf("BOOM!\n");
  127.    
  128.     feldAnzeigenEnde(bombenfeld, zeilen, spalten);
  129.     */
  130.    
  131.     putchar('\n');
  132.    
  133.     return 0;
  134.    
  135. }
  136.  
  137.  
  138. void feldAnzeigenEnde(int feld[ZEILEN][SPALTEN], int zeilen, int spalten){
  139.    
  140.     int i, j;
  141.    
  142.     printf("\n   ");
  143.    
  144.     for (i = 0; i < spalten; i++) {
  145.        
  146.         printf(" %c", GROSS_A + i);
  147.        
  148.     }
  149.    
  150.     putchar('\n');
  151.    
  152.     for (i = 0; i < spalten + spalten + 4; i++) {
  153.        
  154.         putchar('*');
  155.        
  156.     }
  157.    
  158.     putchar('\n');
  159.    
  160.     for (j = 0; j < zeilen; j++) {
  161.        
  162.         printf("%2d ", j + 1);
  163.        
  164.         putchar('|');
  165.        
  166.         for (i = 0; i < spalten; i++) {
  167.            
  168.             if(feld[j][i] == -1){
  169.                
  170.                 printf("X|");
  171.                
  172.             }
  173.             else if(feld[j][i] == 0){
  174.                
  175.                 printf(" |");
  176.                        
  177.             }
  178.             else{
  179.                            
  180.                 printf("%d|", feld[j][i]);
  181.                                    
  182.             }
  183.            
  184.         }
  185.        
  186.         putchar('\n');
  187.        
  188.     }
  189.    
  190.     for (i = 0; i < spalten + spalten + 4; i++) {
  191.            
  192.         putchar('*');
  193.            
  194.     }
  195.    
  196. }
  197.  
  198. void feldFuellen(int feld[ZEILEN][SPALTEN], size_t zeilen, size_t spalten, int bomben){
  199.    
  200.     srand(time(NULL));
  201.    
  202.     int i, bombenzeile, bombenspalte;
  203.    
  204.     for (i = 0; i < bomben;) {
  205.        
  206.         bombenzeile = rand() % zeilen;
  207.         bombenspalte = rand() % spalten;
  208.        
  209.         if(feld[bombenzeile][bombenspalte] == -1){
  210.            
  211.             continue;
  212.            
  213.         }
  214.         else if(feld[bombenzeile][bombenspalte] != -1){
  215.            
  216.             feld[bombenzeile][bombenspalte] = -1;
  217.             i++;
  218.            
  219.         }
  220.        
  221.     }
  222.    
  223. }
  224.  
  225. void feldBerechnen(int feld[ZEILEN][SPALTEN], int zeilen, int spalten){
  226.    
  227.     int i, j, anzahl = 0;
  228.    
  229.     for (j = 0; j < zeilen; j++) {
  230.        
  231.         for (i = 0; i < spalten; i++) {
  232.            
  233.             if(feld[j][i] == -1){
  234.                
  235.                 continue;
  236.                
  237.             }
  238.            
  239.             if(i - 1 >= 0 && j - 1 >= 0){
  240.                
  241.                 if(feld[j - 1][i - 1] == -1){
  242.                    
  243.                     anzahl++;
  244.                    
  245.                 }
  246.                
  247.             }
  248.            
  249.             if(j - 1 >= 0){
  250.                
  251.                 if(feld[j-1][i] == -1){
  252.                    
  253.                     anzahl++;
  254.                    
  255.                 }
  256.                
  257.             }
  258.            
  259.             if(j - 1 >= 0 && i + 1 < spalten){
  260.                
  261.                 if(feld[j-1][i+1] == -1){
  262.                    
  263.                     anzahl++;
  264.                    
  265.                 }
  266.                
  267.             }
  268.            
  269.             if(i - 1 >= 0){
  270.                
  271.                 if(feld[j][i-1] == -1){
  272.                    
  273.                     anzahl++;
  274.                    
  275.                 }
  276.                
  277.             }
  278.            
  279.             if(i + 1 < spalten){
  280.                
  281.                 if(feld[j][i+1] == -1){
  282.                    
  283.                     anzahl++;
  284.                    
  285.                 }
  286.                
  287.             }
  288.            
  289.             if(j + 1 < zeilen && i - 1 >= 0){
  290.                
  291.                 if(feld[j+1][i-1] == -1){
  292.                    
  293.                     anzahl++;
  294.                    
  295.                 }
  296.                
  297.             }
  298.            
  299.             if(j + 1 < zeilen){
  300.                
  301.                 if(feld[j+1][i] == -1){
  302.                    
  303.                     anzahl++;
  304.                    
  305.                 }
  306.                
  307.             }
  308.            
  309.             if(j + 1 < zeilen && i + 1 < spalten){
  310.                
  311.                 if(feld[j+1][i+1] == -1){
  312.                    
  313.                    anzahl++;
  314.                    
  315.                 }
  316.                
  317.             }
  318.            
  319.             feld[j][i] = anzahl;
  320.             anzahl = 0;
  321.            
  322.         }
  323.        
  324.     }
  325.    
  326. }
  327.  
  328. void eingabefeld(int *xkord, int *ykord, int zeilen, int spalten){
  329.    
  330.     printf("\n\nGeben Sie das gewuenschte Feld ein (zB. A5)\n");
  331.    
  332.     int ok;
  333.     char eingabe[300], dummy1, dummy2, kordx;
  334.    
  335.     spalten = spalten + GROSS_A;
  336.    
  337.     do {
  338.        
  339.         printf("--->");
  340.        
  341.         fgets(eingabe, 300, stdin);
  342.        
  343.         ok = sscanf(eingabe, "%c%d%c%c", &kordx, ykord, &dummy1, &dummy2);
  344.        
  345.         kordx = toupper(kordx);
  346.        
  347.         if(ok != 3){
  348.            
  349.             printf("Falsche Eingabe!\n");
  350.            
  351.         }
  352.         else {
  353.        
  354.             !isupper(kordx) ? printf("Kein Spaltenbuchstabe angegeben!\n") : ok;
  355.        
  356.             kordx >= spalten ? printf("Zu grosse Spalte angegeben!\n") : ok;
  357.        
  358.             *ykord > zeilen ? printf("Zu grosse Zeile angegeben!\n") : ok;
  359.        
  360.         }
  361.        
  362.     } while (ok != 3 || !isupper(kordx) || kordx >= spalten || *ykord > zeilen);
  363.    
  364.     *xkord = kordx - GROSS_A;
  365.     (*ykord)--;
  366.    
  367. }
  368.  
  369.  
  370. int pruefBombe(int feld[ZEILEN][SPALTEN], int xkord, int ykord){
  371.    
  372.     if(feld[ykord][xkord] == -1){
  373.        
  374.         return 1;
  375.        
  376.     }
  377.    
  378.     return 0;
  379.    
  380. }
  381.  
  382.  
  383. void feldAnzeigen(int feldberechnet[ZEILEN][SPALTEN], int feldwerte[ZEILEN][SPALTEN], int zeilen, int spalten){
  384.    
  385.     int i, j;
  386.    
  387.     printf("\n   ");
  388.    
  389.     for (i = 0; i < spalten; i++) {
  390.        
  391.         printf(" %c", GROSS_A + i);
  392.        
  393.     }
  394.    
  395.     putchar('\n');
  396.    
  397.     for (i = 0; i < spalten + spalten + 4; i++) {
  398.        
  399.         putchar('*');
  400.        
  401.     }
  402.    
  403.     putchar('\n');
  404.    
  405.     for (j = 0; j < zeilen; j++) {
  406.        
  407.         printf("%2d ", j + 1);
  408.        
  409.         putchar('|');
  410.        
  411.         for (i = 0; i < spalten; i++) {
  412.            
  413.             if(feldwerte[j][i] == 1){
  414.                
  415.                 printf("%d|", feldberechnet[j][i]);
  416.                
  417.             }
  418.             else{
  419.                
  420.                 printf(" |");
  421.                        
  422.             }
  423.            
  424.         }
  425.        
  426.         putchar('\n');
  427.        
  428.     }
  429.    
  430.     for (i = 0; i < spalten + spalten + 4; i++) {
  431.            
  432.         putchar('*');
  433.            
  434.     }
  435.    
  436. }
  437.  
  438. /*
  439. void feldAufdecken(int feldberechnet[ZEILEN][SPALTEN], int feldwerte[ZEILEN][SPALTEN], int xkord, int ykord, int zeilen, int spalten){
  440.    
  441.     if(feldberechnet[ykord][xkord] == 0){
  442.        
  443.         feldwerte[ykord][xkord] = 1;
  444.        
  445.         //while (feldAufdeckenNullen(feldberechnet, feldwerte, zeilen, spalten));
  446.        
  447.     }
  448.    
  449.    
  450.    
  451.    
  452.    
  453. }
  454.  
  455.  
  456. int feldAufdeckenNullen(int feldberechnet[ZEILEN][SPALTEN], int feldwerte[ZEILEN][SPALTEN], int zeilen, int spalten){
  457.    
  458.     int anzahl = 0, i, j;
  459.    
  460.     for (j = 0; j < zeilen; j++) {
  461.        
  462.         for (i = 0; i < spalten; i++) {
  463.            
  464.             if(i - 1 >= 0 && j - 1 >= 0){
  465.                
  466.                
  467.                
  468.             }
  469.            
  470.             if(j - 1 >= 0){
  471.                
  472.                
  473.                
  474.             }
  475.            
  476.             if(j - 1 >= 0 && i + 1 < spalten){
  477.                
  478.                
  479.                
  480.             }
  481.            
  482.             if(i - 1 >= 0){
  483.                
  484.                
  485.                
  486.             }
  487.            
  488.             if(i + 1 < spalten){
  489.                
  490.                
  491.                
  492.             }
  493.            
  494.             if(j + 1 < zeilen && i - 1 >= 0){
  495.                
  496.                
  497.                
  498.             }
  499.            
  500.             if(j + 1 < zeilen){
  501.                
  502.                
  503.                
  504.             }
  505.            
  506.             if(j + 1 < zeilen && i + 1 < spalten){
  507.                
  508.                
  509.                
  510.             }
  511.            
  512.         }
  513.        
  514.     }
  515.    
  516.    
  517. }*/
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!