Pastebin is 300% more awesome when you are logged in. Sign Up, it's FREE!
Public Pastes
Guest

TicTacToe - Komplett

By: Erb1tux on Apr 3rd, 2014  |  syntax: C++  |  size: 14.14 KB  |  views: 3  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  1. /*
  2. Alexander Goldt & Pascal Wendt
  3.  
  4. Wir haben 4 verschiedene Computergegner programmiert mit unterschiedlichen schwierigkeitsgraden
  5. einfach: Die KI raet wo sie setzt
  6.                 implementierung: void easymode
  7. mittel: siehe schwer, aber die KI "vergisst" manchmal zu prüfen ob sie gewinnen kann
  8.                 implementierung: void simHunan
  9. schwer: die KI geht systematisch vor und spielt eine Strategie die es einem Gegner nicht ermöglicht zu gewinnen.
  10.                 es ist maximal ein Unentschieden möglich.
  11.                 implementierung: void schwer
  12. Unmöglich: ein witzgegner der alle Felder mit seinem Zeichen überschreibt
  13.                 implementierung: void unmoeglich
  14. tl;dr
  15. bitte "void schwer" anstatt "void berechneSpielzug" angucken
  16. als Computergegner h auswählen
  17. */
  18. #include<stdio.h>
  19. #include<stdlib.h>
  20. #include<time.h>
  21. #define NONE '\0'
  22. void gibIntroAus();
  23. void gibGewinnerAus(char gewinner);
  24. void gibSpielfeldAus(const char spielfeld[][3]);
  25. void liesSpielzugEin(char spielfeld[][3], char SpielerAmZug);
  26. char hatGewinner(const char spielfeld[][3]);
  27. void berechneSpielzug(char spielfeld[][3], char SpielerAmZug);
  28. int anzahlZuege(const char spielfeld[][3]);
  29. char schwierigkeit();
  30. void easymode(char spielfeld[][3], char spieleramZug);
  31. char gegner(char spieleramzug);
  32. void unmoeglich(char pos[][3], char player);
  33. void schwer(char pos[][3], char player);
  34. int kannOppWin(char pos[][3], char player);
  35. int kannPlayerWin(char pos[][3], char player);
  36. int mitteFrei(char pos[][3], char player);
  37. int randSetzen(char pos[][3], char player);
  38. void simHuman(char pos[][3], char player);
  39. //Implementierungen
  40. void gibIntroAus(){
  41.         printf("Wilkommen zu TicTacToe!\n");
  42.         printf("Sie koennen entweder zu zweit oder gegen den Computer spielen.\n");
  43.         srand(time(NULL));
  44. }
  45. void gibGewinnerAus(char gewinner){
  46.         if (gewinner == 'x')
  47.                 printf("\t\tDer Gewinner ist:\n\t\tX\n", gewinner);
  48.         if (gewinner == 'o')
  49.                 printf("\t\tDer Gewinner ist:\n\t\tO\n", gewinner);
  50.         if (gewinner == '*')
  51.                 printf("Diese Runde ist unentschieden\n");
  52.         else return;
  53. }
  54. void gibSpielfeldAus(const char spielfeld[][3]){
  55.         unsigned int i, j;
  56.         printf("\n  1 2 3 \n");
  57.         printf("--------\n");
  58.         for (i = 0; i < 3; i++){
  59.                 printf("%i|", i+1);
  60.                 for (j = 0; j < 3; j++){
  61.                         if (spielfeld[i][j] == '\0')
  62.                                 printf(" |");
  63.                         if (spielfeld[i][j] == 'x')
  64.                                 printf("X|");
  65.                         if (spielfeld[i][j] == 'o')
  66.                                 printf("O|");
  67.                         if (j == 2)
  68.                                 printf("\n");
  69.                 }
  70.                 printf("--------\n");
  71.         }
  72.         printf("\n\n");
  73. }
  74. void liesSpielzugEin(char spielfeld[][3], char SpielerAmZug){
  75.         char buffer[81];
  76.         int x, y;
  77.         printf("Bitte gib die Koordinaten fuer deinen Zug ein\nSpieler %c\n[x,y]\n",SpielerAmZug);
  78.         gets_s(buffer, 81);
  79.         sscanf_s(buffer, "%d,%d", &y, &x);
  80.         x--;
  81.         y--;
  82.         if ((x >= 0 && x <= 2) && (y >= 0 && y <= 2)){
  83.                 if (spielfeld[x][y] == '\0'){
  84.                         spielfeld[x][y] = SpielerAmZug;
  85.                         return;
  86.                 }
  87.                 else (liesSpielzugEin(spielfeld, SpielerAmZug));
  88.         }
  89. }
  90. char hatGewinner(const char spielfeld[][3]){
  91.         if (spielfeld[0][0] == spielfeld[1][1] && spielfeld[1][1] == spielfeld[2][2] && spielfeld[2][2] != '\0')
  92.                 return spielfeld[0][0];
  93.         if (spielfeld[0][2] == spielfeld[1][1] && spielfeld[1][1] == spielfeld[2][0] && spielfeld[2][0] != '\0')
  94.                 return spielfeld[0][2];
  95.         if (spielfeld[0][0] == spielfeld[1][0] && spielfeld[1][0] == spielfeld[2][0] && spielfeld[2][0] != '\0')
  96.                 return spielfeld[0][0];
  97.         if (spielfeld[0][1] == spielfeld[1][1] && spielfeld[1][1] == spielfeld[2][1] && spielfeld[2][1] != '\0')
  98.                 return spielfeld[0][1];
  99.         if (spielfeld[0][2] == spielfeld[1][2] && spielfeld[1][2] == spielfeld[2][2] && spielfeld[2][2] != '\0')
  100.                 return spielfeld[0][2];
  101.         if (spielfeld[0][0] == spielfeld[0][1] && spielfeld[0][1] == spielfeld[0][2] && spielfeld[0][2] != '\0')
  102.                 return spielfeld[0][0];
  103.         if (spielfeld[1][0] == spielfeld[1][1] && spielfeld[1][1] == spielfeld[1][2] && spielfeld[1][2] != '\0')
  104.                 return spielfeld[1][0];
  105.         if (spielfeld[2][0] == spielfeld[2][1] && spielfeld[2][1] == spielfeld[2][2] && spielfeld[2][2] != '\0')
  106.                 return spielfeld[2][0];
  107.         if (anzahlZuege(spielfeld) == 9)
  108.                 return '*';
  109.         return '\0';
  110.  
  111. }
  112. void berechneSpielzug(char spielfeld[][3], char SpielerAmZug){
  113.         static char diff1;
  114.         static char diff2;
  115.         if (SpielerAmZug == 'x'){
  116.                 if (anzahlZuege(spielfeld) < 2)
  117.                         diff1 = schwierigkeit();
  118.                 if (diff1 == 'e')
  119.                         easymode(spielfeld, SpielerAmZug);
  120.                 if (diff1 == 'm')
  121.                         simHuman(spielfeld, SpielerAmZug);
  122.                 if (diff1 == 'i')
  123.                         unmoeglich(spielfeld, SpielerAmZug);
  124.                 if (diff1 == 'h')
  125.                         schwer(spielfeld, SpielerAmZug);
  126.         }
  127.         else{
  128.                 if (anzahlZuege(spielfeld) < 2)
  129.                         diff2 = schwierigkeit();
  130.                 if (diff2 == 'e')
  131.                         easymode(spielfeld, SpielerAmZug);
  132.                 if (diff2 == 'm')
  133.                         simHuman(spielfeld, SpielerAmZug);
  134.                 if (diff2 == 'i')
  135.                         unmoeglich(spielfeld, SpielerAmZug);
  136.                 if (diff2 == 'h')
  137.                         schwer(spielfeld, SpielerAmZug);
  138.         }
  139. }
  140. char schwierigkeit(){
  141.         char difficulty;
  142.         printf("\nBitte waehlen sie die Schwierigkeit des Computergegners:\nE - Einfach\nM - Mittel\nH - Schwer \nI - Impossible\n>>");
  143.         /*
  144.         einfach  - Zufälliges setzen  
  145.         schwer - Setzen mit system / kein Sieg mehr möglich durch den Gegner der KI
  146.         Impossible  - Es wird alles  mit dem Zeichen der KI überschrieben  / Scherzmodus
  147.         Mittel - wie Schwer, nur werden random teile der strategie "vergessen"  / Gewinnen möglich evtl.
  148.         */
  149.         difficulty = getchar();
  150.         while (getchar() != '\n');
  151.         switch (difficulty){
  152.         case 'e':
  153.                 return 'e';
  154.         case 'E':
  155.                 return 'e';
  156.         case 'h':
  157.                 return 'h';
  158.         case 'H':
  159.                 return 'h';
  160.         case 'i':
  161.                 return 'i';
  162.         case 'I':
  163.                 return 'i';
  164.         case'm':
  165.                 return 'm';
  166.         case 'M':
  167.                 return 'm';
  168.                 schwierigkeit();
  169.                 break;
  170.         }
  171.         return 'e';
  172. }
  173. //Die Implementierungen für die Schwierigkeiten
  174. void easymode(char spielfeld[][3], char spieleramZug){
  175.         int x ;
  176.         int y ;
  177.         x = rand() % 3;
  178.         y = rand() % 3;
  179.         while (spielfeld[x][y] != '\0'){
  180.                 x = rand() % 3;
  181.                 y = rand() % 3;
  182.         }
  183.         spielfeld[x][y] = spieleramZug;
  184. }
  185. void unmoeglich(char pos[][3], char player){
  186.         unsigned int i, j;
  187.         for (i = 0; i < 3; i++){
  188.                 for (j = 0; j < 3; j++){
  189.                         pos[i][j] = player;
  190.                 }
  191.         }
  192.         printf("Du kannst mich mal %c!\n", gegner);
  193.         return;
  194. }
  195. void schwer(char pos[][3], char player){
  196.         if (kannOppWin(pos, player))
  197.                 return;
  198.         if (kannPlayerWin(pos, player))
  199.                 return;
  200.         if (mitteFrei(pos, player))
  201.                 return;
  202.         if (eckeSetzen(pos, player))
  203.                 return;
  204.         if (randSetzen(pos, player))
  205.                 return;
  206.         else{
  207.                 printf("Ich weis nicht wo ich noch mein %c setzen soll.\nEs scheint mir alles voll zu sein!\nVielleicht hat %c ja geschummelt!\nSCHIEBUNG!!!", player, gegner(player));
  208.         }
  209. }
  210. void simHuman(char pos[][3], char player){
  211.         int forget = 0;
  212.         forget = rand() % 2;
  213.         if (forget != 0 && kannOppWin(pos, player))
  214.                 return;
  215.         if (forget != 1 && kannPlayerWin(pos, player))
  216.                 return;
  217.         if (mitteFrei(pos, player))
  218.                 return;
  219.         if (eckeSetzen(pos, player))
  220.                 return;
  221.         if (randSetzen(pos, player))
  222.                 return;
  223.         else{
  224.                 printf("Ich weis nicht wo ich noch mein %c setzen soll.\nEs scheint mir alles voll zu sein!\nVielleicht hat %c ja geschummelt!\nSCHIEBUNG!!!", player, gegner(player));
  225.         }
  226. }
  227. //Die Implementierungen für "schwer" und "simHuman"
  228. int kannOppWin(char pos[][3], char player){
  229.         if ((pos[0][0] == pos[0][2]) && (pos[0][1] == NONE) && (pos[0][0] == gegner(player))){
  230.                 pos[0][1] = player;
  231.                 return 1;
  232.         }
  233.         if ((pos[0][0] == pos[2][0]) && pos[1][0] == NONE && pos[0][0] == gegner(player)){
  234.                 pos[1][0] = player;
  235.                 return 1;
  236.         }
  237.         if ((pos[2][0] == pos[2][2]) && pos[2][1] == NONE && pos[2][0] == gegner(player)){
  238.                 pos[2][1] = player;
  239.                 return 1;
  240.         }
  241.         if ((pos[2][2] == pos[0][2]) && pos[1][2] == NONE && pos[2][2] == gegner(player)){
  242.                 pos[1][2] = player;
  243.                 return 1;
  244.         }
  245.         if ((pos[0][0] == pos[2][2]) && pos[1][1] == NONE && pos[0][0] == gegner(player)){
  246.                 pos[1][1] = player;
  247.                 return 1;
  248.         }
  249.         if ((pos[2][0] == pos[0][2]) && pos[1][1] == NONE && pos[2][0] == gegner(player)){
  250.                 pos[1][1] = player;
  251.                 return 1;
  252.         }
  253.         if (pos[0][0] == pos[0][1] && pos[0][2] == NONE && pos[0][0] == gegner(player)){
  254.                 pos[0][2] = player;
  255.                 return 1;
  256.         }
  257.         if (pos[0][1] == pos[0][2] && pos[0][0] == NONE && pos[0][1] == gegner(player)){
  258.                 pos[0][0] = player;
  259.                 return 1;
  260.         }
  261.         if (pos[0][0] == pos[1][0] && pos[2][0] == NONE && pos[0][0] == gegner(player)){
  262.                 pos[2][0] = player;
  263.                 return 1;
  264.         }
  265.         if (pos[1][0] == pos[2][0] && pos[0][0] == NONE && pos[0][0] == gegner(player)){
  266.                 pos[0][0] = player;
  267.                 return 1;
  268.         }
  269.         if (pos[2][0] == pos[2][1] && pos[2][2] == NONE && pos[2][0] == gegner(player)){
  270.                 pos[2][2] = player;
  271.                 return 1;
  272.         }
  273.         if (pos[2][1] == pos[2][2] && pos[2][0] == NONE && pos[2][1] == gegner(player)){
  274.                 pos[2][0] = player;
  275.                 return 1;
  276.         }
  277.         if (pos[0][2] == pos[1][2] && pos[2][2] == NONE && pos[0][2] == gegner(player)){
  278.                 pos[2][2] = player;
  279.                 return 1;
  280.         }
  281.         if (pos[1][2] == pos[2][2] && pos[0][2] == NONE && pos[1][2] == gegner(player)){
  282.                 pos[0][2] = player;
  283.                 return 1;
  284.         }
  285.         if (pos[1][2] == pos[1][1] && pos[1][0] == NONE && pos[1][2] == gegner(player)){
  286.                 pos[1][0] = player;
  287.                 return 1;
  288.         }
  289.         if (pos[1][0] == pos[1][1] && pos[1][2] == NONE && pos[1][1] == gegner(player)){
  290.                 pos[1][2] = player;
  291.                 return 1;
  292.         }
  293.         if (pos[1][1] == pos[2][2] && pos[0][0] == NONE && pos[2][2] == gegner(player)){
  294.                 pos[0][0] = player;
  295.                 return 1;
  296.         }
  297.         if (pos[0][0] == pos[1][1] && pos[2][2] == NONE && pos[1][1] == gegner(player)){
  298.                 pos[2][2] = player;
  299.                 return 1;
  300.         }
  301.         if (pos[0][1] == pos[1][1] && pos[2][1] == NONE && pos[1][1] == gegner(player)){
  302.                 pos[2][1] = player;
  303.                 return 1;
  304.         }
  305.         if (pos[1][1] == pos[2][1] && pos[0][1] == NONE && pos[2][1] == gegner(player)){
  306.                 pos[0][1] = player;
  307.                 return 1;
  308.         }
  309.         if (pos[0][2] == pos[1][1] && pos[2][0] == NONE && pos[0][2] == gegner(player)){
  310.                 pos[2][0] = player;
  311.                 return 1;
  312.         }
  313.         if (pos[1][1] == pos[2][0] && pos[0][2] == NONE && pos[1][1] == gegner(player)){
  314.                 pos[0][2] = player;
  315.                 return 1;
  316.         }
  317.         if (pos[0][1] == pos[2][1] && pos[1][1] == NONE && pos[0][1] == gegner(player)){
  318.                 pos[1][1] = player;
  319.                 return 1;
  320.         }
  321.         if (pos[1][0] == pos[1][2] && pos[1][1] == NONE && pos[1][0] == gegner(player)){
  322.                 pos[1][1] = player;
  323.                 return 1;
  324.         }
  325.         else return 0;
  326. }
  327. int kannPlayerWin(char pos[][3], char player){
  328.         //die bedingung &&pos[][] == player ist überflüssug aber da weil ich es mit suchen und ersetzen geänder hab
  329.         if ((pos[0][0] == pos[0][2]) && (pos[0][1] == NONE) && (pos[0][0] == player)){
  330.                 pos[0][1] = player;
  331.                 return 1;
  332.         }
  333.         if ((pos[0][0] == pos[2][0]) && pos[1][0] == NONE && pos[0][0] == player){
  334.                 pos[1][0] = player;
  335.                 return 1;
  336.         }
  337.         if ((pos[2][0] == pos[2][2]) && pos[2][1] == NONE && pos[2][0] == player){
  338.                 pos[2][1] = player;
  339.                 return 1;
  340.         }
  341.         if ((pos[2][2] == pos[0][2]) && pos[1][2] == NONE && pos[2][2] == player){
  342.                 pos[1][2] = player;
  343.                 return 1;
  344.         }
  345.         if ((pos[0][0] == pos[2][2]) && pos[1][1] == NONE && pos[0][0] == player){
  346.                 pos[1][1] = player;
  347.                 return 1;
  348.         }
  349.         if ((pos[2][0] == pos[0][2]) && pos[1][1] == NONE && pos[2][0] == player){
  350.                 pos[1][1] = player;
  351.                 return 1;
  352.         }
  353.         if (pos[0][0] == pos[0][1] && pos[0][2] == NONE && pos[0][0] == player){
  354.                 pos[0][2] = player;
  355.                 return 1;
  356.         }
  357.         if (pos[0][1] == pos[0][2] && pos[0][0] == NONE && pos[0][1] == player){
  358.                 pos[0][0] = player;
  359.                 return 1;
  360.         }
  361.         if (pos[0][0] == pos[1][0] && pos[2][0] == NONE && pos[0][0] == player){
  362.                 pos[2][0] = player;
  363.                 return 1;
  364.         }
  365.         if (pos[1][0] == pos[2][0] && pos[0][0] == NONE && pos[0][0] == player){
  366.                 pos[0][0] = player;
  367.                 return 1;
  368.         }
  369.         if (pos[2][0] == pos[2][1] && pos[2][2] == NONE && pos[2][0] == player){
  370.                 pos[2][2] = player;
  371.                 return 1;
  372.         }
  373.         if (pos[2][1] == pos[2][2] && pos[2][0] == NONE && pos[2][1] == player){
  374.                 pos[2][0] = player;
  375.                 return 1;
  376.         }
  377.         if (pos[0][2] == pos[1][2] && pos[2][2] == NONE && pos[0][2] == player){
  378.                 pos[2][2] = player;
  379.                 return 1;
  380.         }
  381.         if (pos[1][2] == pos[2][2] && pos[0][2] == NONE && pos[1][2] == player){
  382.                 pos[0][2] = player;
  383.                 return 1;
  384.         }
  385.         if (pos[1][2] == pos[1][1] && pos[1][0] == NONE && pos[1][2] == player){
  386.                 pos[1][0] = player;
  387.                 return 1;
  388.         }
  389.         if (pos[1][0] == pos[1][1] && pos[1][2] == NONE && pos[1][1] == player){
  390.                 pos[1][2] = player;
  391.                 return 1;
  392.         }
  393.         if (pos[1][1] == pos[2][2] && pos[0][0] == NONE && pos[2][2] == player){
  394.                 pos[0][0] = player;
  395.                 return 1;
  396.         }
  397.         if (pos[0][0] == pos[1][1] && pos[2][2] == NONE && pos[1][1] == player){
  398.                 pos[2][2] = player;
  399.                 return 1;
  400.         }
  401.         if (pos[0][1] == pos[1][1] && pos[2][1] == NONE && pos[1][1] == player){
  402.                 pos[2][1] = player;
  403.                 return 1;
  404.         }
  405.         if (pos[1][1] == pos[2][1] && pos[0][1] == NONE && pos[2][1] == player){
  406.                 pos[0][1] = player;
  407.                 return 1;
  408.         }
  409.         if (pos[0][2] == pos[1][1] && pos[2][0] == NONE && pos[0][2] == player){
  410.                 pos[2][0] = player;
  411.                 return 1;
  412.         }
  413.         if (pos[1][1] == pos[2][0] && pos[0][2] == NONE && pos[1][1] == player){
  414.                 pos[0][2] = player;
  415.                 return 1;
  416.         }
  417.         if (pos[0][1] == pos[2][1] && pos[1][1] == NONE && pos[0][1] == player){
  418.                 pos[1][1] = player;
  419.                 return 1;
  420.         }
  421.         if (pos[1][0] == pos[1][2] && pos[1][1] == NONE && pos[1][0] == player){
  422.                 pos[1][1] = player;
  423.                 return 1;
  424.         }
  425.         else return 0;
  426. }
  427. int mitteFrei(char pos[][3], char player){
  428.         if (pos[1][1] == NONE){
  429.                 pos[1][1] = player;
  430.                 return 1;
  431.         }
  432.         else return 0;
  433. }
  434. int eckeSetzen(char pos[][3], char player){
  435.  
  436.         if (pos[0][0] == NONE){
  437.                 pos[0][0] = player;
  438.                 return 1;
  439.         }
  440.         if (pos[0][2] == NONE){
  441.                 pos[0][2] = player;
  442.                 return 1;
  443.         }
  444.         if (pos[2][0] == NONE){
  445.                 pos[2][0] = player;
  446.                 return 1;
  447.         }
  448.         if (pos[2][2] == NONE){
  449.                 pos[2][2] = player;
  450.                 return 1;
  451.         }
  452.         else return 0;
  453.  
  454. }
  455. int randSetzen(char pos[][3], char player){
  456.         int i, j;
  457.         //Ich geh alle felder mit der for schleife durch weil wie anderen sowieso schon gesetzt sein müssten und ich das so einfacher finde.
  458.         //Bei einem 3x3 ist das auch nicht wichtig denke ich, da es keine geschwindigkeitsvorteile bringt nur die kantenfelder zu nehmen.
  459.         for (i = 0; i < 3; i++){
  460.                 for (j = 0; j < 3; j++){
  461.                         if (pos[i][j] == NONE){
  462.                                 pos[i][j] = player;
  463.                                 return 1;
  464.                         }
  465.                 }
  466.         }
  467.         return 0;
  468. }
  469. // Allgemeine hilfsfunktionen
  470. int anzahlZuege(const char spielfeld[][3]){
  471.         unsigned int i, j;
  472.         unsigned int anzahl = 0;
  473.         for (i = 0; i < 3; i++){
  474.                 for (j = 0; j < 3; j++){
  475.                         if (spielfeld[i][j] != '\0')
  476.                                 anzahl++;
  477.                 }
  478.         }
  479.         return anzahl;
  480. }
  481. char gegner(char spieleramzug){
  482.         if (spieleramzug == 'x')
  483.                 return 'o';
  484.         else return 'x';
  485. }
create a new version of this paste RAW Paste Data