Akuba

Schiffe Versenken (geht sogar!)

Oct 20th, 2017
464
0
Never
1
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 11.28 KB | None | 0 0
  1. /*
  2.                 "Schiffe" versenken
  3.     (Wären das dann nicht eigendlich U-Boote wenn man sie nur sieht wenn sie getroffen wurden?)
  4.          Code geschrieben von Tobias Schmidt
  5.  
  6.          Legende:
  7.             ~ - Wasser
  8.             S - Schiff
  9.             o - Getroffenes "Schiff"
  10.             x - Fehlgeschlagener Schuss
  11.     Developer Log:
  12.         19.10.2017 - 10:00 - Irgendwie geht da was nicht.
  13.         19.10.2017 - 11:47 - Fast den kleinen Schrank zerlegt.
  14.         19.10.2017 - 11:49 - Der mist funktioniert nicht ...
  15.         20.10.2017 - 8:00  - Es geht endlich! \(0.0)/
  16.  
  17. */
  18. #include <stdio.h>
  19. #include <stdbool.h>
  20. #include <time.h>
  21. #include <stdlib.h>
  22. #include <unistd.h>
  23.  
  24. #define sizeX 8
  25. #define sizeY 8
  26. #define sizeTotal ((sizeX+1)*10+sizeY)
  27. #define maxCachedGegnerZuege 4
  28. #define maxShips sizeX+sizeX
  29.  
  30. // Interne Variablen
  31. #define wasser  0
  32. #define daneben 1
  33. #define treffer 2
  34. #define schiff  3
  35. #define bereits_Daneben     11
  36. #define bereits_Getroffen   22
  37. #define player1_Gewonnen    42  // Lösung auf alles.
  38. #define player1_Verloren    31  // 31 hör zu, eine Line macht dich nicht cool ...
  39.  
  40. // Das sieht man später anstatt der Variablen
  41. #define wasser_Icon "~ "
  42. #define daneben_Icon "x "
  43. #define treffer_Icon "� "
  44. #define schiff_Icon "0 "
  45.  
  46. static int spielFeldPlayer[sizeTotal] = { 0 }; // static soll sicherstellen das auch
  47. static int spielFeldGegner[sizeTotal] = { 0 }; // wirklich nur DIESE variable genutzt wird, und keine kopie
  48. static int playerShipsLeft;
  49. static int gegnerShipsLeft;
  50.  
  51. static int mode;
  52.  
  53. static bool spieler1AmZug = true;
  54. static bool spielVerlassen = false;
  55. static bool zumHauptmenu = false;
  56.  
  57. static int letzteComputerZuege[maxCachedGegnerZuege][2];
  58. static int computerZuege = 0;
  59.  
  60. static int rundenZaehler;
  61. static int timeSinceStart;
  62. // Headerkrams
  63.  
  64. void generiereSpielFeld(bool istSpieler1);
  65. void zeigeSpielFeld(bool nurGetroffen);
  66. int macheSpielZug (int zugX, int zugY);
  67. bool menschlicherSpielZug(int debugx, int debugy);
  68. bool computerSpielZug(bool rekursive);
  69. void clear();
  70.  
  71. void showFieldHeader();
  72.  
  73. void showFieldHeader() {
  74.         int sekunde = (int)(time(NULL)-timeSinceStart), minute = 0;
  75.         while(sekunde > 60)
  76.         {
  77.             sekunde -= 60;
  78.             minute++;
  79.         }
  80.         printf("Runde %d | Zeit: %.2d:%.2d\n", rundenZaehler, minute, sekunde);
  81.         if (spieler1AmZug && mode == 1) printf("\n\t\tDu bist am Zug!\n"
  82.                                                "\tKI Schiffe: %d | Deine Schiffe: %d\n", gegnerShipsLeft, playerShipsLeft);
  83.         else if (spieler1AmZug && mode == 2) printf("\n\t\tSpieler 1 ist am Zug!\n"
  84.                                                     "\tSchiffe Spieler 2: %d | Deine Schiffe: %d\n", gegnerShipsLeft, playerShipsLeft);
  85.         else if (!spieler1AmZug && mode == 2) printf("\n\t\tSpieler 2 ist am Zug!\n"
  86.                                                      "\tSchiffe Spieler 1: %d | Deine Schiffe: %d\n", playerShipsLeft, gegnerShipsLeft);
  87.         else if (spieler1AmZug && mode == 3) printf("\n\t\tTestmodus\n");
  88.         else if (!spieler1AmZug && mode == 1) printf("\n\t\tDie KI ist am Zug!\n"
  89.            "\tKI Schiffe: %d | Deine Schiffe: %d\n", gegnerShipsLeft, playerShipsLeft);
  90. }
  91.  
  92. void clear() {
  93.     printf("\e[1;1H\e[2J");
  94. }
  95.  
  96. bool computerSpielZug(bool rekursive) {
  97.     bool ret = false;
  98.     if (!rekursive) {
  99.         clear();
  100.         showFieldHeader();
  101.         zeigeSpielFeld(false);
  102.         sleep(1);
  103.     }
  104.     int nextx = rand() % sizeX-1;
  105.     int nexty = rand() % sizeY-1;;
  106.     /*if(computerZuege == 0){   // Es geht, ich fasse hier nichtsmehr an!
  107.         nextx = rand() % sizeX-1;
  108.         nexty = rand() % sizeY-1;
  109.         letzteComputerZuege[computerZuege][0] = nextx;
  110.         letzteComputerZuege[computerZuege][1] = nexty;
  111.         computerZuege++;
  112.     } */
  113.     int status = macheSpielZug(nextx, nexty);
  114.     //if (!rekursive) {
  115.     clear();
  116.     showFieldHeader();
  117.  
  118.     zeigeSpielFeld(false);
  119.     //}
  120.     if (status == treffer) {
  121.         printf("\n\t Verdammt! Der Computer hat eins unserer Schiffe versenkt\n");
  122.     } else if (status == daneben) {
  123.         //ret = computerSpielZug(true);
  124.         printf("\n\t Daneben! - Uns kann nichts aufhalten!\n");
  125.     } else if (status == bereits_Daneben) {
  126.          ret = computerSpielZug(true);
  127.         //printf("\n\t Erneut Daneben... - Das sollte eigendlich nicht möglich sein ...!\n");
  128.     } else if (status == player1_Gewonnen) {
  129.         printf("\n\t SIEG! Wir haben gewonnen!!\n");
  130.         ret = true;
  131.     } else if (status == player1_Verloren) {
  132.         printf("\n\t NIEDERLAGE! Der Computer hat gewonnen..\n");
  133.         ret = true;
  134.     }
  135.     else if ( status == bereits_Getroffen) {
  136.         ret = computerSpielZug(true);
  137.         //printf("\n\t Schiff bereits getroffen! - Entwickler hat verpennt das zu vermeiden...\n");
  138.     }
  139.     else {
  140.         printf("\n\t Unbekannter Zustand... Der Entwickler ist immernoch Doof!\n");
  141.     }
  142.     if (!rekursive){
  143.         sleep(3);
  144.         clear();
  145.     }
  146.     return ret;
  147. }
  148.  
  149. bool menschlicherSpielZug(int debugx, int debugy) {
  150.     showFieldHeader();
  151.     if (mode == 3) zeigeSpielFeld(false);
  152.     else zeigeSpielFeld(true);
  153.     int nextx;
  154.     if (debugx == -1){
  155.         do {    // Nested Loop, hurray!
  156.             printf("\n\t Naechster Zug: X Koordinate: ");
  157.             scanf("%d", &nextx);
  158.             nextx--;
  159.             if (nextx > sizeX-1)
  160.             {
  161.                 printf("\tDie X Koordinate ist zu gross!\n");
  162.             } else if (nextx < 0) {
  163.                 printf("\tDie X Koordinate ist zu klein!\n");
  164.             } else {
  165.                 break;
  166.             }
  167.         } while (1);
  168.     } else nextx = debugx;
  169.     int nexty;
  170.     if (debugy == -1) {
  171.         do {    // Nested Loop again, hurray!
  172.             printf("\n\t Naechster Zug: Y Koordinate: ");
  173.             scanf("%d", &nexty);
  174.             nexty--;
  175.             if (nexty > sizeY-1)
  176.             {
  177.                 printf("\tDie Y Koordinate ist zu gross!");
  178.             } else if (nexty < 0) {
  179.                 printf("\tDie Y Koordinate ist zu klein!");
  180.             } else {
  181.                 break;
  182.             }
  183.  
  184.         } while (1);
  185.     } else nexty = debugy;
  186.     if (mode == 3 || mode == 4) printf("X: %d - Y: %d", nextx, nexty);
  187.     int status = macheSpielZug(nextx, nexty);
  188.     clear();
  189.     showFieldHeader();
  190.     if (mode == 3) zeigeSpielFeld(false);
  191.     else zeigeSpielFeld(true);
  192.     if (status == treffer) {
  193.         printf("\n\t TREFFER! - Gegnerisches Schiff versenkt!\n");
  194.     } else if (status == daneben) {
  195.  
  196.         printf("\n\t Daneben! - Leider nur Wasseratome getroffen!\n");
  197.     } else if (status == bereits_Daneben) {
  198.         printf("\n\t Immernoch Daneben! - Hier ist nach wie vor kein Schiff!\n\t\t\tNeuer versuch!\n");
  199.         sleep(2);
  200.         clear();
  201.         return menschlicherSpielZug(debugx, debugy);
  202.     } else if (status == player1_Gewonnen) {
  203.         printf("\n\t SIEG! Spieler 1 Hat gewonnen!!\n");
  204.         return true;
  205.     } else if (status == player1_Verloren) {
  206.         if(mode == 1) printf("\n\t NIEDERLAGE! Der Computer hat gewonnen..\n");
  207.         else printf("\n\t SIEG! Spieler 2 Hat gewonnen!!\n");
  208.         return true;
  209.     }
  210.     else if ( status == bereits_Getroffen) {
  211.         printf("\n\t Schiff bereits getroffen! - Die sind doch bereits alle tot!...\n\t\t\tNeuer Versuch!");
  212.         sleep(2);
  213.         clear();
  214.         return menschlicherSpielZug(debugx, debugy);
  215.     }
  216.     else {
  217.         printf("\n\t Unbekannter Zustand... Der Entwickler ist Doof!\n");
  218.     }
  219.     sleep(2);
  220.     clear();
  221.     return false;
  222. }
  223.  
  224. int macheSpielZug (int zugX, int zugY) {
  225.     int status = -1;
  226.     if (spieler1AmZug) status = spielFeldGegner[(zugX*10)+zugY];
  227.     else status = spielFeldPlayer[(zugX*10)+zugY];
  228.     if (status == schiff) {
  229.         if (spieler1AmZug) {
  230.             spielFeldGegner[(zugX*10)+zugY] = treffer;
  231.             gegnerShipsLeft--;
  232.             if(gegnerShipsLeft == 0) return player1_Gewonnen;
  233.         }
  234.         else {
  235.             spielFeldPlayer[(zugX*10)+zugY] = treffer;
  236.             playerShipsLeft--;
  237.             if(playerShipsLeft == 0) return player1_Verloren;
  238.         }
  239.         return treffer;
  240.     }
  241.     else if (status == daneben) return bereits_Daneben;
  242.     else if (status == wasser) {
  243.         if (spieler1AmZug) spielFeldGegner[(zugX*10)+zugY] = daneben;
  244.         else spielFeldPlayer[(zugX*10)+zugY] = daneben;
  245.         return daneben;
  246.     }
  247.     else if (status == treffer) return bereits_Getroffen;
  248. }
  249.  
  250. void generiereSpielFeld(bool istSpieler1) {
  251.     int totalShipps = 0;
  252.     /*for (int x = 0; x < sizeX; x++)
  253.     {
  254.         for (int y = 0; y < sizeY; y++)
  255.         {
  256.             if(istSpieler1) spielFeldPlayer[x][y] = 0;
  257.             else spielFeldGegner[x][y] = 0;
  258.         }
  259.     }*/
  260.     for (int k = 0; k<maxShips; k++) {
  261.         int x = rand() % sizeX;
  262.         int y = rand() % sizeY;
  263.         if(istSpieler1)
  264.         {
  265.             if (spielFeldPlayer[(x*10)+y] != schiff) {
  266.                 spielFeldPlayer[(x*10)+y] = schiff;
  267.                 playerShipsLeft++;
  268.             }
  269.             else k--;
  270.         } else {
  271.             if (spielFeldGegner[(x*10)+y] != schiff) {
  272.                 spielFeldGegner[(x*10)+y] = schiff;
  273.                 gegnerShipsLeft++;
  274.             }
  275.             else k--;
  276.         }
  277.     }
  278.  
  279. }
  280.  
  281. void zeigeSpielFeld(bool nurGetroffen)
  282. {
  283.     for (int y = 0; y < sizeY; y++)
  284.     {  
  285.         for (int x = 0; x < sizeX; x++)
  286.         {
  287.             // AußenBorder Start
  288.             if (x == 0 && y == 0){
  289.                 printf("\n\t\t# X ");
  290.                 for (int k = 0; k < sizeX; k++)
  291.                 {
  292.                     printf("%d ", k+1);
  293.                 }
  294.                 printf("\n\t\tY\n\t\t1   ");
  295.             }
  296.             if (x == 0 && y != 0)
  297.             {
  298.                 printf("\t\t%d   ", y + 1);
  299.             }
  300.             // AußenBorder Ende
  301.             // Spielfeld Zeichnen Start
  302.             int toPrint = -1;
  303.             if(spieler1AmZug) toPrint = spielFeldGegner[(x*10)+y];
  304.             else toPrint = spielFeldPlayer[(x*10)+y];
  305.             if (nurGetroffen){
  306.                 if(toPrint == schiff) toPrint = wasser;
  307.             }
  308.  
  309.             switch (toPrint)
  310.             {
  311.                 case wasser:    printf(wasser_Icon); break;
  312.                 case daneben:   printf(daneben_Icon); break;
  313.                 case treffer:   printf(treffer_Icon); break;
  314.                 case schiff:    printf(schiff_Icon); break;
  315.             }
  316.             // Spielfeld Zeichnen Ende
  317.  
  318.         }
  319.         //int temp;
  320.         //scanf("%d", &temp);
  321.         printf("\n");
  322.     }
  323. }
  324.  
  325. int main() {
  326.     // Variablen Initialisieren
  327.  
  328.    
  329.     // Modi: 0 - Ungenutzt, 1 - gegen KI, 2 - 2 Spieler, 3 - Testmodus, 4 - Ein Feld automatisch ausfüllen.
  330.     bool spielVerlassen = false;
  331.  
  332.     int debugx = 0;
  333.     int debugy = 0;
  334.     srand(time(NULL)); // Wir setzten einen Seed für den Zufallsgenerator.
  335.     clear();
  336.     printf("**********************************\n");
  337.     printf("* \"Schiffe\" versenken! Oder so...*\n");
  338.     printf("**********************************\n\n");
  339.     printf("\t\t Hauptmenue:\n");
  340.     printf("\t1) Neues Spiel (gegen KI)\n");
  341.     printf("\t2) Neues Spiel (2 Spieler Modus)\n");
  342.     printf("\t3) Testmodus\n");
  343.     printf("\t4) Autofill\n");
  344.     printf("\n\t0) Spiel Beenden\n");
  345.     printf("\n\tAuswaehlen: ");
  346.     int hauptMenue = 1;
  347.     scanf("%d", &hauptMenue);
  348.  
  349.     switch (hauptMenue)
  350.     {
  351.         case 1: mode = 1; break;
  352.         case 2: mode = 2; break;
  353.         case 3: mode = 3; break;
  354.         case 4: mode = 4; break;
  355.         case 0: return 0; break; // break ist echt voll super sinnvoll hier. Echt jetzt... nicht ...
  356.     }
  357.     timeSinceStart = (int)time(NULL);
  358.     clear();
  359.     //generiereSpielFeld(false);
  360.     if(mode != 3 && mode != 4){
  361.         //printf("Generiere Spielfelder:");
  362.         //printf("\n\t- Spieler 1 Komplett -");
  363.         generiereSpielFeld(true); // Wir generieren für den Spieler das Spielfeld
  364.         //if (mode == 1) printf("\n\t- KI-Gegner Komplett - \n");
  365.         //else printf("\n\t- Spieler 2 Komplett - \n");
  366.         generiereSpielFeld(false); // Wir generieren für den (KI-)Gegner das Spielfeld
  367.     } else if (mode == 4) generiereSpielFeld(false);
  368.     else printf("\n");
  369.     do {
  370.         if (spieler1AmZug)
  371.         {
  372.             rundenZaehler++;
  373.             if (mode == 4) {
  374.                 menschlicherSpielZug(debugx, debugy);
  375.                 if (debugx < 7) debugx++;
  376.                 else {
  377.                     debugx = 0;
  378.                     debugy++;
  379.                 }
  380.                 if (debugy == 8)  {
  381.                     spielVerlassen = !spielVerlassen;
  382.                     break;
  383.                 }
  384.                 //sleep(1);
  385.  
  386.             } else {
  387.                 spielVerlassen = menschlicherSpielZug(-1, -1);
  388.                 if (mode != 3) spieler1AmZug = !spieler1AmZug;
  389.             }
  390.  
  391.         } else {
  392.             if (mode == 1) {
  393.                 spielVerlassen = computerSpielZug(false);
  394.                 spieler1AmZug = !spieler1AmZug;
  395.             } else {
  396.                 spielVerlassen = menschlicherSpielZug(-1, -1); // Mode ist total sinnlos hier... | Wir das das Spielfeld von Spieler 1.
  397.                 spieler1AmZug = !spieler1AmZug;
  398.             }
  399.         }
  400.     } while(!spielVerlassen);
  401.     return 0;
  402. }
Advertisement
Comments
  • User was banned
Add Comment
Please, Sign In to add comment