SHARE
TWEET

Untitled

a guest Dec 8th, 2019 58 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <time.h>
  4. #include <iostream>
  5. #include <windows.h>
  6.  
  7. #define KONIEC -1
  8. #define GRACZ2_WYGRYWA 0
  9. #define GRACZ1_WYGRYWA 1
  10. #define REMIS 2
  11. #define RANK 15
  12. #define PLIK "Eksperyment2.txt"
  13. #define ZAMIANA 1
  14. #define BRAK_ZAMIANY 0
  15.  
  16. using namespace std;
  17.  
  18. enum kolory_kart {
  19.     PIK,    //0
  20.     KIER,   //1
  21.     TREFL,  //2
  22.     KARO    //3
  23. };
  24.  
  25. enum strategie {
  26.     PODSTAWOWA = 1,
  27.     LOSOWA,
  28.     WSCIEKLA,
  29.     POKOJOWA
  30. };
  31.  
  32. struct karta_t {
  33.     int kolor;
  34.     int wartosc;
  35. };
  36.  
  37. struct gracz {
  38.     karta_t karta;
  39.     gracz* kolejny;
  40. };
  41.  
  42. int porownajKarty(gracz* gracz1, gracz* gracz2) {
  43.     if (gracz1->kolejny == NULL) {
  44.         cout << "GRACZ 2 WYGRYWA! " << endl;
  45.         return KONIEC;
  46.     }
  47.     else if (gracz2->kolejny == NULL) {
  48.         cout << "GRACZ 1 WYGRYWA! " << endl;
  49.         return KONIEC;
  50.     }
  51.     else {
  52.         cout << gracz1->kolejny->karta.wartosc << "/" << gracz1->kolejny->karta.kolor;
  53.         cout << "  vs  ";
  54.         cout << gracz2->kolejny->karta.wartosc << "/" << gracz2->kolejny->karta.kolor << endl;
  55.  
  56.         if (gracz1->kolejny->karta.wartosc > gracz2->kolejny->karta.wartosc) {
  57.             cout << "GRACZ 1 WYGRYWA TE RUNDE" << endl;
  58.             return GRACZ1_WYGRYWA;
  59.         }
  60.         else if (gracz1->kolejny->karta.wartosc < gracz2->kolejny->karta.wartosc) {
  61.             cout << "GRACZ 2 WYGRYWA TE RUNDE" << endl;
  62.             return GRACZ2_WYGRYWA;
  63.         }
  64.         else if (gracz1->kolejny->karta.wartosc == gracz2->kolejny->karta.wartosc) {
  65.             cout << "WOJNA!" << endl;
  66.             return REMIS;
  67.         }
  68.     }
  69. }
  70.  
  71. void przetrzymajKarty(gracz* player1, gracz* player2, int zwyciezca) {
  72.     struct gracz* karty_gracza1 = (struct gracz*) malloc(sizeof(gracz));
  73.     struct gracz* karty_gracza2 = (struct gracz*) malloc(sizeof(gracz));
  74.     karty_gracza1->karta = player1->kolejny->karta;
  75.     karty_gracza2->karta = player2->kolejny->karta;
  76.  
  77.     karty_gracza1->kolejny = NULL;
  78.     karty_gracza2->kolejny = NULL;
  79.     if (zwyciezca == GRACZ1_WYGRYWA) {
  80.         karty_gracza1->kolejny = karty_gracza2;
  81.         gracz* p1 = player1;
  82.         while (p1->kolejny != NULL) {
  83.             p1 = p1->kolejny;
  84.         }
  85.         p1->kolejny = karty_gracza1;
  86.     }
  87.     if (zwyciezca == GRACZ2_WYGRYWA) {
  88.         karty_gracza2->kolejny = karty_gracza1;
  89.         gracz* p2 = player2;
  90.         while (p2->kolejny != NULL) {
  91.             p2 = p2->kolejny;
  92.         }
  93.         p2->kolejny = karty_gracza2;
  94.     }
  95. }
  96.  
  97. void fuzjaKart(struct gracz* player, struct gracz* player_win, struct gracz* player_lose) { //Połączenie kart, które brały udział w wojnie w logiczny sposób
  98.     gracz* gracz_win = player_win;
  99.     while (gracz_win->kolejny != NULL) {
  100.         gracz_win = gracz_win->kolejny;
  101.     }
  102.     gracz_win->kolejny = player_lose->kolejny;
  103.     gracz* p = player;
  104.     while (p->kolejny != NULL) {
  105.         p = p->kolejny;
  106.     }
  107.     p->kolejny = player_win->kolejny;
  108. }
  109.  
  110. void zapiszKarty(struct gracz* player, struct gracz* wojna) {   //Kontener na karty biorące udział w wojnie
  111.     gracz* zawodnik = player;
  112.     while (zawodnik->kolejny != NULL) {
  113.         zawodnik = zawodnik->kolejny;
  114.     }
  115.     zawodnik->kolejny = wojna->kolejny;
  116. }
  117.  
  118. void wypiszKarty(struct gracz* gracz1, struct gracz* gracz2, int rozmiar) {         //Wypisywanie kart posiadanych przez każdego z graczy
  119.     gracz* gr1 = gracz1;
  120.     gracz* gr2 = gracz2;
  121.     cout << "GRACZ1: ";
  122.     while (gr1->kolejny != NULL) {
  123.         cout << gr1->kolejny->karta.wartosc << "/" << gr1->kolejny->karta.kolor << " | ";
  124.         gr1 = gr1->kolejny;
  125.     }
  126.     cout << endl;
  127.     cout << "GRACZ2: ";
  128.     while (gr2->kolejny != NULL) {
  129.         cout << gr2->kolejny->karta.wartosc << "/" << gr2->kolejny->karta.kolor << " | ";
  130.         gr2 = gr2->kolejny;
  131.     }
  132.     cout << endl;
  133. }
  134.  
  135. int wyborKarty(struct gracz* gracz_1, int tryb,struct gracz* gracz_2) {             //MADRA WOJNA
  136.     int wybor;
  137.     if (tryb == PODSTAWOWA) {
  138.         cout << "Aby wybrac karte: " << gracz_1->kolejny->karta.wartosc << "/" << gracz_1->kolejny->karta.kolor <<" do bitwy, kliknij 1" << endl;
  139.         cout << "Jesli jednak ma to byc karta: " << gracz_1->kolejny->kolejny->karta.wartosc << "/" << gracz_1->kolejny->kolejny->karta.kolor << " kliknij 2" << endl;
  140.         cin >> wybor;
  141.         if (wybor == 1) {
  142.             return BRAK_ZAMIANY;
  143.         }
  144.         else {
  145.             return ZAMIANA;
  146.         }
  147.     }
  148.     else if (tryb == LOSOWA) {
  149.         wybor = rand() % 2 + 1;
  150.         if (wybor == 1) {
  151.             return BRAK_ZAMIANY;
  152.         }
  153.         else {
  154.             return ZAMIANA;
  155.         }
  156.     }
  157.     else if (tryb == WSCIEKLA) {
  158.         if (gracz_1->kolejny->karta.wartosc == gracz_2->kolejny->karta.wartosc) {
  159.             return BRAK_ZAMIANY;
  160.         }
  161.         else {
  162.             if ((gracz_1->kolejny->karta.wartosc > gracz_2->kolejny->karta.wartosc) && (gracz_1->kolejny->karta.wartosc < gracz_1->kolejny->kolejny->karta.wartosc)) {
  163.                 return BRAK_ZAMIANY;
  164.             }
  165.             else if ((gracz_1->kolejny->karta.wartosc < gracz_2->kolejny->karta.wartosc) && (gracz_1->kolejny->karta.wartosc > gracz_1->kolejny->kolejny->karta.wartosc)) {
  166.                 return ZAMIANA;
  167.             }
  168.             else if (gracz_1->kolejny->kolejny->karta.wartosc > gracz_2->kolejny->karta.wartosc) {
  169.                 return ZAMIANA;
  170.             }
  171.             else if (gracz_1->kolejny->kolejny->karta.wartosc == gracz_2->kolejny->karta.wartosc) {
  172.                 return ZAMIANA;
  173.             }
  174.             else {
  175.                 return BRAK_ZAMIANY;
  176.             }
  177.         }
  178.     }
  179.     else if (tryb == POKOJOWA) {
  180.         if (gracz_1->kolejny->karta.wartosc == gracz_2->kolejny->karta.wartosc) {
  181.             return ZAMIANA;
  182.         }
  183.         else if (gracz_1->kolejny->kolejny->karta.wartosc == gracz_2->kolejny->karta.wartosc) {
  184.             return BRAK_ZAMIANY;
  185.         }
  186.         else {
  187.         if ((gracz_1->kolejny->karta.wartosc < gracz_2->kolejny->karta.wartosc) && (gracz_1->kolejny->kolejny->karta.wartosc < gracz_2->kolejny->karta.wartosc)) {
  188.             if (gracz_1->kolejny->karta.wartosc <= gracz_1->kolejny->kolejny->karta.wartosc) {
  189.                 return BRAK_ZAMIANY;
  190.             }
  191.             else {
  192.                 return ZAMIANA;
  193.             }
  194.         }
  195.         else if ((gracz_1->kolejny->kolejny->karta.wartosc > gracz_2->kolejny->karta.wartosc) && (gracz_1->kolejny->kolejny->karta.wartosc < gracz_1->kolejny->karta.wartosc)) {
  196.             return ZAMIANA;
  197.         }
  198.         else if ((gracz_1->kolejny->karta.wartosc > gracz_2->kolejny->karta.wartosc) && (gracz_1->kolejny->karta.wartosc < gracz_1->kolejny->kolejny->karta.wartosc)) {
  199.             return BRAK_ZAMIANY;
  200.         }
  201.         else if ((gracz_1->kolejny->karta.wartosc > gracz_2->kolejny->karta.wartosc) && (gracz_1->kolejny->karta.wartosc < gracz_2->kolejny->karta.wartosc)) {
  202.             return BRAK_ZAMIANY;
  203.         }
  204.         else {
  205.             return ZAMIANA;
  206.         }
  207.         }
  208.     }
  209. }
  210.  
  211. void zamienKarty(struct gracz* zawodnik) {
  212.     gracz* gr = zawodnik->kolejny;
  213.     zawodnik->kolejny = zawodnik->kolejny->kolejny;
  214.     gr->kolejny = gr->kolejny->kolejny;
  215.     zawodnik->kolejny->kolejny = gr;
  216. }
  217.  
  218. void potasujWygrane(struct gracz* gracz_1, struct gracz* gracz_2) {
  219.     struct gracz* tymczasowe1 = gracz_1;
  220.     struct gracz* tymczasowe2 = gracz_2;
  221.         int losowa = rand() % 2;
  222.         if (losowa) {
  223.             gracz_1 = tymczasowe2;
  224.             gracz_2 = tymczasowe1;
  225.         }
  226. }
  227.  
  228. karta_t* kartyZWojny(struct gracz* gracz_1, struct gracz* gracz_2, int licznik_wojen) {
  229.     int liczba_kart = licznik_wojen * 2 + 1;
  230.     struct gracz* tymczasowe1 = gracz_1;
  231.     struct gracz* tymczasowe2 = gracz_2;
  232.     tymczasowe1 = tymczasowe1->kolejny;
  233.     tymczasowe2 = tymczasowe2->kolejny;
  234.     struct karta_t* talia = (karta_t*)malloc(sizeof(karta_t));
  235.     for (int i = 0; i < liczba_kart*2; i+=2) {
  236.         talia[i] = tymczasowe1->karta;
  237.         talia[i + 1] = tymczasowe2->karta;
  238.         tymczasowe1 = tymczasowe1->kolejny;
  239.         tymczasowe2 = tymczasowe2->kolejny;
  240.     }
  241.     free(tymczasowe1);
  242.     free(tymczasowe2);
  243.     return talia;
  244.  
  245. }
  246.  
  247. /*      FUNKCJE RANKINGOWE
  248.    
  249. int policzRange1(struct gracz* gracz_) {
  250.     gracz* pierwszy = gracz_;
  251.     int ranga = 0;
  252.     while (pierwszy->kolejny != NULL) {
  253.         ranga += pierwszy->kolejny->karta.wartosc;
  254.         pierwszy = pierwszy->kolejny;
  255.     }
  256.     return ranga;
  257. }
  258.  
  259. int policzRange3(struct gracz* gracz_) {
  260.     gracz* pierwszy = gracz_;
  261.     int ranga = 0;
  262.     while (pierwszy->kolejny != NULL) {
  263.         if (pierwszy->kolejny->karta.wartosc == 14) { //AS liczony *2,5 (bo jego wartosc to 14, dodajemy 7 i jeszcze 14 z kolejnej instrukcji if)
  264.             ranga += 7;
  265.         }
  266.         if (pierwszy->kolejny->karta.wartosc > 9) { //Karty od 10 do KRÓLA(13) liczone podwójnie
  267.             ranga += pierwszy->kolejny->karta.wartosc;
  268.         }
  269.         if (ranga += pierwszy->kolejny->karta.wartosc > 3) { //2 i 3 nie są wcale liczone
  270.             ranga += pierwszy->kolejny->karta.wartosc;
  271.         }
  272.         pierwszy = pierwszy->kolejny;
  273.     }
  274.     return ranga;
  275. }  
  276.  
  277. int policzRange2(struct gracz* gracz_) {
  278.     gracz* pierwszy = gracz_;
  279.     int ranga = 0;
  280.     while (pierwszy->kolejny != NULL) {
  281.         if(pierwszy->kolejny->karta.wartosc >=9)
  282.             ranga += pierwszy->kolejny->karta.wartosc;
  283.         pierwszy = pierwszy->kolejny;
  284.     }
  285.     return ranga;
  286. }*/
  287.  
  288. void rozdajKartyZMadrej(struct gracz* gracz_1, struct gracz* gracz_2, karta_t talia_[], int rozmiar_) {
  289.     struct gracz* tymczasowe_1 = gracz_1;
  290.     struct gracz* tymczasowe_2 = gracz_2;
  291.     for (int i = 0, j = (rozmiar_ / 2); i < (rozmiar_ /2) ;  i++,j++) {
  292.         tymczasowe_1->kolejny->karta = talia_[i];
  293.         tymczasowe_2->kolejny->karta = talia_[j];
  294.         tymczasowe_1 = tymczasowe_1->kolejny;
  295.         tymczasowe_2 = tymczasowe_2->kolejny;
  296.     }
  297.     tymczasowe_1->kolejny = NULL;
  298.     tymczasowe_2->kolejny = NULL;
  299. }
  300.  
  301. void pozyczKarty(struct gracz* potrzebujacy, struct gracz* oddajacy, int liczba_kart, int liczba_wojen) {       //Funkcja odpowiedzialna za turę wspomaganą, warunki są powiązane z tymi znajdującymi się w main'ie, dotyczącymi wariantu B
  302.     gracz* oddajacy_tymczasowa = oddajacy->kolejny;
  303.     if (liczba_kart != 2) {
  304.         for (int i = 0; i < 1; i++)
  305.             oddajacy_tymczasowa = oddajacy_tymczasowa->kolejny;
  306.     }
  307.     if (liczba_kart == 1 && liczba_wojen > 1) {
  308.         oddajacy->kolejny->kolejny = oddajacy->kolejny->kolejny->kolejny;
  309.         oddajacy_tymczasowa->kolejny = NULL;
  310.     }
  311.     else if (liczba_wojen >= 2 && liczba_kart == 2) {
  312.         oddajacy->kolejny = oddajacy->kolejny->kolejny->kolejny;
  313.         oddajacy_tymczasowa->kolejny->kolejny = NULL;
  314.     }
  315.     else if (liczba_wojen==1 && liczba_kart==2) {
  316.         oddajacy_tymczasowa = oddajacy_tymczasowa->kolejny;
  317.         oddajacy->kolejny->kolejny = oddajacy->kolejny->kolejny->kolejny->kolejny;
  318.         oddajacy_tymczasowa->kolejny->kolejny = NULL;
  319.     }
  320.     else if (liczba_wojen == 1 && liczba_kart == 1) {
  321.         oddajacy_tymczasowa = oddajacy_tymczasowa->kolejny;
  322.         oddajacy->kolejny->kolejny->kolejny = oddajacy->kolejny->kolejny->kolejny->kolejny;
  323.         oddajacy_tymczasowa->kolejny = NULL;
  324.     }
  325.     else {
  326.         oddajacy->kolejny->kolejny = oddajacy->kolejny->kolejny->kolejny->kolejny;
  327.         oddajacy_tymczasowa->kolejny->kolejny = NULL;
  328.     }
  329.  
  330.     if (liczba_wojen == 1 && liczba_kart == 1) {
  331.         potrzebujacy->kolejny->kolejny->kolejny = oddajacy_tymczasowa;
  332.     }
  333.     else if (liczba_wojen != 1 && liczba_kart == 2) {
  334.         potrzebujacy->kolejny = oddajacy_tymczasowa;
  335.     }
  336.     else
  337.         potrzebujacy->kolejny->kolejny = oddajacy_tymczasowa;
  338. }
  339.  
  340. void rozdawanieKart(struct gracz* player, struct karta_t talia[], int rozmiar) {
  341.     if (rozmiar != 0) {
  342.         struct gracz* pomoc = (struct gracz*) malloc(sizeof(gracz));
  343.         pomoc->karta = talia[rozmiar - 1];
  344.         pomoc->kolejny = player->kolejny;
  345.         player->kolejny = pomoc;
  346.         rozdawanieKart(player->kolejny, talia, rozmiar - 1);  //Rozdawanie kolejnych kart z talii, kazdy z graczy otrzymuje polowe przetasowanej talii
  347.     }
  348. }
  349.  
  350. karta_t* tworzenieTalii(struct karta_t talia[], int rozmiar) {
  351.     talia = (karta_t*)malloc(rozmiar * sizeof(karta_t));
  352.     if (talia == NULL) {
  353.         cout << "Brak pamięci";
  354.         return NULL;
  355.     }
  356.     int ranking = RANK;
  357.     int kolor = 0;
  358.     for (int i = 0; i < rozmiar; i++) {
  359.         talia[i].wartosc = --ranking;       //Przydzielanie każdej karcie wartośći [2-14] gdzie 14=AS
  360.         talia[i].kolor = kolor;             //Przydzielanie każdej karcie koloru, patrz. enum
  361.         if (ranking == RANK - rozmiar / 4) {
  362.             ranking = 15;
  363.             kolor++;
  364.         }
  365.     }
  366.     return talia;
  367. }
  368.  
  369. karta_t* tasowanieTalii(struct karta_t talia[], int rozmiar) {  //Tasowanie kart wykonywane 5-krotnie, dla większej pewności, że będą dobrze potasowane oraz przedewszystkim dla realizmu gry
  370.     int wartosc_pomocnicza;
  371.     int kolor_pomocniczy;
  372.     for (int i = 0; i < 5 * rozmiar; i++) {
  373.         int indeks_pomocniczy = rand() % rozmiar;
  374.         wartosc_pomocnicza = talia[i % rozmiar].wartosc;
  375.         kolor_pomocniczy = talia[i % rozmiar].kolor;
  376.         talia[i % rozmiar].wartosc = talia[indeks_pomocniczy].wartosc;
  377.         talia[i % rozmiar].kolor = talia[indeks_pomocniczy].kolor;
  378.  
  379.         talia[indeks_pomocniczy].wartosc = wartosc_pomocnicza;
  380.         talia[indeks_pomocniczy].kolor = kolor_pomocniczy;
  381.     }
  382.     return talia;
  383. }
  384.  
  385. int main() {
  386.     srand(time(NULL));
  387.     //FILE* zapis;
  388.     //zapis = fopen(PLIK, "w");
  389.     struct karta_t* karty = NULL;
  390.     int rozmiar_talii;
  391.     bool gra = true;
  392.     short int wynik;
  393.     int licznik_wojen = 0;
  394.     int brakujace_karty = 0;
  395.     int tury_wspomagane = 0;
  396.     cout << "GRA W WOJNE" << "\n\n";
  397.     cout << "Podaj rozmiar talii, ktora chcesz zagrac: ";
  398.     cin >> rozmiar_talii;
  399.     karty = tworzenieTalii(karty, rozmiar_talii);
  400.  
  401.     tasowanieTalii(karty, rozmiar_talii);
  402.  
  403.     //ROZDAWANIE KART GRACZOM
  404.  
  405.     gracz* gracz1 = (gracz*)malloc(sizeof(gracz));
  406.     gracz* gracz2 = (gracz*)malloc(sizeof(gracz));
  407.     rozdawanieKart(gracz1, karty, rozmiar_talii / 2);
  408.     rozdawanieKart(gracz2, karty + rozmiar_talii / 2, rozmiar_talii / 2);
  409.  
  410.     gracz* gr1_ = gracz1;
  411.     gracz* gr2_ = gracz2;
  412.  
  413.     for (int i = 0; i < rozmiar_talii / 2; i++) {       //Przypisanie ostatniej karcie każdego gracza wskaznika na kolejna == NULL, dzieki temu prostsze stanie sie porowywanie kart
  414.         gr1_ = gr1_->kolejny;
  415.         gr2_ = gr2_->kolejny;
  416.     }
  417.     gr1_->kolejny = NULL;
  418.     gr2_->kolejny = NULL;
  419.  
  420.     /* SPRAWADZENIE CZY KARTY ROZDAJA SIE POPRAWNIE
  421.     int licznik = 1;
  422.     gracz* gr1 = gracz1;
  423.     gracz* gr2 = gracz2;
  424.     while (licznik <= rozmiar_talii/2) {
  425.         cout <<licznik<< "    " << gr1->kolejny->karta.wartosc << "  " << gr1->kolejny->karta.kolor << endl;
  426.         gr1 = gr1->kolejny;
  427.         cout <<licznik++ << ".2  "<< gr2->kolejny->karta.wartosc << "  " << gr2->kolejny->karta.kolor << endl;
  428.         gr2 = gr2->kolejny;
  429.     } */
  430.  
  431.     // WOJNA
  432.  
  433.         char komenda;
  434.         cout << "Wybierz warinat gry sposrod A i B oraz M (madra wojna): ";
  435.         cin >> komenda;
  436.         switch (komenda)
  437.         {
  438.         case 'A':           //WARIANT B
  439.             while (gra) {
  440.                 wypiszKarty(gracz1, gracz2, rozmiar_talii);
  441.                 tury_wspomagane = 0;
  442.                 wynik = porownajKarty(gracz1, gracz2);
  443.  
  444.                 if (wynik == GRACZ1_WYGRYWA || wynik == GRACZ2_WYGRYWA) {
  445.                     przetrzymajKarty(gracz1, gracz2, wynik);
  446.  
  447.                     gracz1 = gracz1->kolejny;
  448.                     gracz2 = gracz2->kolejny;
  449.                 }
  450.                 else if (wynik == REMIS) {
  451.                     gracz* g1 = (gracz*)malloc(sizeof(gracz));
  452.                     gracz* g2 = (gracz*)malloc(sizeof(gracz));
  453.                     while (wynik == REMIS) {
  454.                         ++licznik_wojen;
  455.                         gracz* g1_remis = (gracz*)malloc(sizeof(gracz));
  456.                         gracz* g2_remis = (gracz*)malloc(sizeof(gracz));
  457.                         if (gracz1->kolejny == NULL && gracz2->kolejny == NULL) {
  458.                             cout << "REMIS!" << endl;
  459.                             gra = false;
  460.                             break;
  461.                         }
  462.                         if (gracz1 != NULL && gracz1->kolejny != NULL && gracz1->kolejny->kolejny != NULL) {
  463.                             g1_remis->kolejny = gracz1->kolejny;
  464.                             if (licznik_wojen == 1 && gracz1->kolejny->kolejny->kolejny != NULL) {
  465.                                 gracz1->kolejny = gracz1->kolejny->kolejny->kolejny->kolejny;
  466.                                 g1_remis->kolejny->kolejny->kolejny->kolejny = NULL;
  467.                             }
  468.                             else {
  469.                                 gracz1->kolejny = gracz1->kolejny->kolejny->kolejny;
  470.                                 g1_remis->kolejny->kolejny->kolejny = NULL;
  471.                             }
  472.                         }
  473.                         else {
  474.                             cout << "\n" << "Gracz 2 wygrywa przez brak kart do stoczenia wojny przez przeciwnika!" << endl;
  475.                             gra = false;
  476.                             break;
  477.                         }
  478.                         if (gracz2 != NULL && gracz2->kolejny != NULL && gracz2->kolejny->kolejny != NULL) {
  479.                             g2_remis->kolejny = gracz2->kolejny;
  480.                             if (licznik_wojen == 1 && gracz2->kolejny->kolejny->kolejny != NULL) {
  481.                                 gracz2->kolejny = gracz2->kolejny->kolejny->kolejny->kolejny;
  482.                                 g2_remis->kolejny->kolejny->kolejny->kolejny = NULL;
  483.                             }
  484.                             else {
  485.                                 gracz2->kolejny = gracz2->kolejny->kolejny->kolejny;
  486.                                 g2_remis->kolejny->kolejny->kolejny = NULL;
  487.                             }
  488.                         }
  489.                         else {
  490.                             cout << "\n" << "Gracz 1 wygrywa przez brak kart do stoczenia wojny przez przeciwnika!" << endl;
  491.                             gra = false;
  492.                             break;
  493.                         }
  494.                         if (licznik_wojen == 1)
  495.                             wynik = porownajKarty(g1_remis->kolejny->kolejny, g2_remis->kolejny->kolejny);
  496.                         else
  497.                             wynik = porownajKarty(g1_remis->kolejny, g2_remis->kolejny);
  498.                         if (licznik_wojen == 1) {
  499.                             g1 = g1_remis;
  500.                             g2 = g2_remis;
  501.                         }
  502.                         else {
  503.                             zapiszKarty(g1, g1_remis);
  504.                             zapiszKarty(g2, g2_remis);
  505.                         }
  506.                     }
  507.                     if (wynik == GRACZ1_WYGRYWA) {
  508.                         fuzjaKart(gracz1, g1, g2);
  509.                         licznik_wojen = 0;
  510.                     }
  511.                     else if (wynik == GRACZ2_WYGRYWA) {
  512.                         fuzjaKart(gracz2, g2, g1);
  513.                         licznik_wojen = 0;
  514.                     }
  515.                 }
  516.                 else if (wynik == KONIEC) {
  517.                     gra = false;
  518.                 }
  519.             }
  520.             break;
  521.  
  522.         case 'B' :          //Wariant B
  523.         while (gra) {
  524.             wypiszKarty(gracz1, gracz2, rozmiar_talii);
  525.             wynik = porownajKarty(gracz1, gracz2);
  526.             tury_wspomagane = 0;
  527.  
  528.             if (wynik == GRACZ1_WYGRYWA || wynik == GRACZ2_WYGRYWA) {
  529.                 przetrzymajKarty(gracz1, gracz2, wynik);
  530.  
  531.                 gracz1 = gracz1->kolejny;
  532.                 gracz2 = gracz2->kolejny;
  533.             }
  534.             else if (wynik == REMIS) {
  535.                 gracz* g1 = (gracz*)malloc(sizeof(gracz));
  536.                 gracz* g2 = (gracz*)malloc(sizeof(gracz));
  537.                 while (wynik == REMIS) {
  538.                     ++licznik_wojen;
  539.                     gracz* g1_remis = (gracz*)malloc(sizeof(gracz));
  540.                     gracz* g2_remis = (gracz*)malloc(sizeof(gracz));
  541.                     if (gracz1->kolejny == NULL && gracz2->kolejny == NULL) {
  542.                         cout << "REMIS!" << endl;
  543.                         gra = false;
  544.                         break;
  545.                     }
  546.                     if (tury_wspomagane == 0) {
  547.                         if (gracz1->kolejny == NULL && licznik_wojen > 1) {                         //Poniższe 4 przypadki definiują zachowanie gry w przypadku wariantu B, konkretnie gdy jednemu z graczy "brakują" 2 KARTY
  548.                             brakujace_karty = 2;
  549.                             pozyczKarty(gracz1, gracz2, brakujace_karty, licznik_wojen);
  550.                             tury_wspomagane++;
  551.                         }
  552.                         else if (gracz1->kolejny->kolejny == NULL && licznik_wojen == 1) {
  553.                             brakujace_karty = 2;
  554.                             pozyczKarty(gracz1, gracz2, brakujace_karty, licznik_wojen);
  555.                             tury_wspomagane++;
  556.                         }
  557.                         else if (gracz2->kolejny == NULL && licznik_wojen > 1) {
  558.                             brakujace_karty = 2;
  559.                             pozyczKarty(gracz2, gracz1, brakujace_karty, licznik_wojen);
  560.                             tury_wspomagane++;
  561.                         }
  562.                         else if (gracz2->kolejny->kolejny == NULL && licznik_wojen == 1) {
  563.                             brakujace_karty = 2;
  564.                             pozyczKarty(gracz2, gracz1, brakujace_karty, licznik_wojen);
  565.                             tury_wspomagane++;                                                      //Koniec przypadków dla brakujących 2 KART
  566.                         }
  567.                         else if (gracz1->kolejny->kolejny == NULL && licznik_wojen > 1) {           //Poniższe 4 przypadki definiują zachowanie gry w przypadku wariantu B, konkretnie gdy jednemu z graczy "brakuje" 1 KARTA
  568.                             brakujace_karty = 1;
  569.                             pozyczKarty(gracz1, gracz2, brakujace_karty, licznik_wojen);
  570.                             tury_wspomagane++;
  571.                         }
  572.                         else if (gracz1->kolejny->kolejny->kolejny == NULL && licznik_wojen == 1) {
  573.                             brakujace_karty = 1;
  574.                             pozyczKarty(gracz1, gracz2, brakujace_karty, licznik_wojen);
  575.                             tury_wspomagane++;
  576.                         }
  577.                         else if (gracz2->kolejny->kolejny == NULL && licznik_wojen > 1) {
  578.                             brakujace_karty = 1;
  579.                             pozyczKarty(gracz2, gracz1, brakujace_karty, licznik_wojen);
  580.                             tury_wspomagane++;
  581.                         }
  582.                         else if (gracz2->kolejny->kolejny->kolejny == NULL && licznik_wojen == 1) {
  583.                             brakujace_karty = 1;
  584.                             pozyczKarty(gracz2, gracz1, brakujace_karty, licznik_wojen);
  585.                             tury_wspomagane++;                                                      //Koniec przypadków dla brakującej 1 KARTY
  586.                         }
  587.                     }
  588.                     if (gracz1 != NULL && gracz1->kolejny != NULL && gracz1->kolejny->kolejny != NULL) {
  589.                         g1_remis->kolejny = gracz1->kolejny;
  590.                         if (licznik_wojen == 1 && gracz1->kolejny->kolejny->kolejny != NULL) {
  591.                             gracz1->kolejny = gracz1->kolejny->kolejny->kolejny->kolejny;
  592.                             g1_remis->kolejny->kolejny->kolejny->kolejny = NULL;
  593.                         }
  594.                         else {
  595.                             gracz1->kolejny = gracz1->kolejny->kolejny->kolejny;
  596.                             g1_remis->kolejny->kolejny->kolejny = NULL;
  597.                         }
  598.                     }
  599.                     else {
  600.                         cout << "\n" << "Gracz 2 wygrywa przez brak kart do stoczenia wojny przez przeciwnika!" << endl;
  601.                         gra = false;
  602.                         break;
  603.                     }
  604.                     if (gracz2 != NULL && gracz2->kolejny != NULL && gracz2->kolejny->kolejny != NULL) {
  605.                         g2_remis->kolejny = gracz2->kolejny;
  606.                         if (licznik_wojen == 1 && gracz2->kolejny->kolejny->kolejny != NULL) {
  607.                             gracz2->kolejny = gracz2->kolejny->kolejny->kolejny->kolejny;
  608.                             g2_remis->kolejny->kolejny->kolejny->kolejny = NULL;
  609.                         }
  610.                         else {
  611.                             gracz2->kolejny = gracz2->kolejny->kolejny->kolejny;
  612.                             g2_remis->kolejny->kolejny->kolejny = NULL;
  613.                         }
  614.                     }
  615.                     else {
  616.                         cout << "\n" << "Gracz 1 wygrywa przez brak kart do stoczenia wojny przez przeciwnika!" << endl;
  617.                         gra = false;
  618.                         break;
  619.                     }
  620.                     if (licznik_wojen == 1)
  621.                         wynik = porownajKarty(g1_remis->kolejny->kolejny, g2_remis->kolejny->kolejny);
  622.                     else
  623.                         wynik = porownajKarty(g1_remis->kolejny, g2_remis->kolejny);
  624.                     if (licznik_wojen == 1) {
  625.                         g1 = g1_remis;
  626.                         g2 = g2_remis;
  627.                     }
  628.                     else {
  629.                         zapiszKarty(g1, g1_remis);
  630.                         zapiszKarty(g2, g2_remis);
  631.                     }
  632.                 }
  633.                 if (wynik == GRACZ1_WYGRYWA) {
  634.                     fuzjaKart(gracz1, g1, g2);
  635.                     licznik_wojen = 0;
  636.                     tury_wspomagane = 0;
  637.                 }
  638.                 else if (wynik == GRACZ2_WYGRYWA) {
  639.                     fuzjaKart(gracz2, g2, g1);
  640.                     licznik_wojen = 0;
  641.                     tury_wspomagane = 0;
  642.                 }
  643.             }
  644.             else if (wynik == KONIEC) {
  645.                 gra = false;
  646.             }
  647.         }
  648.         break;
  649.         case 'M' :          //MĄDRA WOJNA
  650.             int tury = 0;
  651.             int zamiana;
  652.             int tryb1,tryb2;
  653.             cout << "Wybierz strategie: " << endl;
  654.             cout << " 1.Podstawowa \n 2.Losowa \n 3.Wsciekla \n 4.Pokojowa \n Wpisz numer strategii" << endl;
  655.             cout << " Strategia gracz1: ";
  656.             cin >> tryb1;
  657.             cout << " Strategia gracz2: ";
  658.             cin >> tryb2;
  659.             while (gra) {
  660.                 wypiszKarty(gracz1, gracz2, rozmiar_talii);
  661.                 if (gracz1->kolejny == NULL) {
  662.                     cout << "GRACZ 2 WYGRYWA! " << endl;
  663.                     gra = false;
  664.                     break;
  665.                 }
  666.                 else if (gracz2->kolejny == NULL) {
  667.                     cout << "GRACZ 1 WYGRYWA! " << endl;
  668.                     gra = false;
  669.                     break;
  670.                 }
  671.                 if (tury % 2 == 0) {
  672.                     zamiana = wyborKarty(gracz2, tryb2, gracz1);
  673.                     if (zamiana) {
  674.                         zamienKarty(gracz2);
  675.                     }
  676.                 }
  677.                 else {
  678.                     zamiana = wyborKarty(gracz1, tryb1, gracz2);
  679.                     if (zamiana) {
  680.                         zamienKarty(gracz1);
  681.                     }
  682.                 }
  683.                 tury++;
  684.  
  685.                 tury_wspomagane = 0;
  686.                 wynik = porownajKarty(gracz1, gracz2);
  687.  
  688.                 if (wynik == GRACZ1_WYGRYWA || wynik == GRACZ2_WYGRYWA) {
  689.                     przetrzymajKarty(gracz1, gracz2, wynik);
  690.  
  691.                     gracz1 = gracz1->kolejny;
  692.                     gracz2 = gracz2->kolejny;
  693.                 }
  694.                 else if (wynik == REMIS) {
  695.                     gracz* g1 = (gracz*)malloc(sizeof(gracz));
  696.                     gracz* g2 = (gracz*)malloc(sizeof(gracz));
  697.                     while (wynik == REMIS) {
  698.                         ++licznik_wojen;
  699.                         gracz* g1_remis = (gracz*)malloc(sizeof(gracz));
  700.                         gracz* g2_remis = (gracz*)malloc(sizeof(gracz));
  701.                         if (gracz1->kolejny == NULL && gracz2->kolejny == NULL) {
  702.                             cout << "REMIS!" << endl;
  703.                             gra = false;
  704.                             break;
  705.                         }
  706.                         if (gracz1 != NULL && gracz1->kolejny != NULL && gracz1->kolejny->kolejny != NULL) {
  707.                             g1_remis->kolejny = gracz1->kolejny;
  708.                             if (licznik_wojen == 1 && gracz1->kolejny->kolejny->kolejny != NULL) {
  709.                                 gracz1->kolejny = gracz1->kolejny->kolejny->kolejny->kolejny;
  710.                                 g1_remis->kolejny->kolejny->kolejny->kolejny = NULL;
  711.                             }
  712.                             else {
  713.                                 gracz1->kolejny = gracz1->kolejny->kolejny->kolejny;
  714.                                 g1_remis->kolejny->kolejny->kolejny = NULL;
  715.                             }
  716.                         }
  717.                         else {
  718.                             cout << "\n" << "Gracz 2 wygrywa przez brak kart do stoczenia wojny przez przeciwnika!" << endl;
  719.                             gra = false;
  720.                             break;
  721.                         }
  722.                         if (gracz2 != NULL && gracz2->kolejny != NULL && gracz2->kolejny->kolejny != NULL) {
  723.                             g2_remis->kolejny = gracz2->kolejny;
  724.                             if (licznik_wojen == 1 && gracz2->kolejny->kolejny->kolejny != NULL) {
  725.                                 gracz2->kolejny = gracz2->kolejny->kolejny->kolejny->kolejny;
  726.                                 g2_remis->kolejny->kolejny->kolejny->kolejny = NULL;
  727.                             }
  728.                             else {
  729.                                 gracz2->kolejny = gracz2->kolejny->kolejny->kolejny;
  730.                                 g2_remis->kolejny->kolejny->kolejny = NULL;
  731.                             }
  732.                         }
  733.                         else {
  734.                             cout << "\n" << "Gracz 1 wygrywa przez brak kart do stoczenia wojny przez przeciwnika!" << endl;
  735.                             gra = false;
  736.                             break;
  737.                         }
  738.                         if (licznik_wojen == 1)
  739.                             wynik = porownajKarty(g1_remis->kolejny->kolejny, g2_remis->kolejny->kolejny);
  740.                         else
  741.                             wynik = porownajKarty(g1_remis->kolejny, g2_remis->kolejny);
  742.                         if (licznik_wojen == 1) {
  743.                             g1 = g1_remis;
  744.                             g2 = g2_remis;
  745.                         }
  746.                         else {
  747.                             zapiszKarty(g1, g1_remis);
  748.                             zapiszKarty(g2, g2_remis);
  749.                         }
  750.                     }
  751.                     if (wynik == GRACZ1_WYGRYWA) {
  752.                         if (licznik_wojen == 0)
  753.                             potasujWygrane(g1, g2);             //W przypadku tylko 2 kart, bez wojny
  754.                         else {
  755.                             karta_t* talia_tymczasowa = (karta_t*)malloc(sizeof(karta_t));
  756.                             talia_tymczasowa = kartyZWojny(g1, g2, licznik_wojen);
  757.                             int rozmiar_talii_tymczasowej = (licznik_wojen * 2 + 1) * 2;
  758.                             tasowanieTalii(talia_tymczasowa, rozmiar_talii_tymczasowej);
  759.                             rozdajKartyZMadrej(g1, g2, talia_tymczasowa, rozmiar_talii_tymczasowej);
  760.                         }
  761.                         fuzjaKart(gracz1, g1, g2);
  762.                         licznik_wojen = 0;
  763.                     }
  764.                     else if (wynik == GRACZ2_WYGRYWA) {
  765.                         if(licznik_wojen==0)
  766.                             potasujWygrane(g1, g2);         //W przypadku tylko 2 kart, bez wojny
  767.                         else {
  768.                             karta_t* talia_tymczasowa = (karta_t*)malloc(sizeof(karta_t));
  769.                             talia_tymczasowa = kartyZWojny(g2, g1, licznik_wojen);
  770.                             int rozmiar_talii_tymczasowej = (licznik_wojen * 2 + 1) * 2;
  771.                             tasowanieTalii(talia_tymczasowa, rozmiar_talii_tymczasowej);
  772.                             rozdajKartyZMadrej(g2, g1, talia_tymczasowa, rozmiar_talii_tymczasowej);
  773.                         }
  774.                         fuzjaKart(gracz2, g2, g1);
  775.                         licznik_wojen = 0;
  776.                     }
  777.                 }
  778.                 else if (wynik == KONIEC) {
  779.                     gra = false;
  780.                 }
  781.             }
  782.     }
  783.         //fprintf(zapis, "%d\t %d\t %d\t %d\n", gracz1_wygrywa, r1, r2, gracz2_wygrywa);                //Pozostałości po zapisie danych z symulacji(eksperyment 2) do pliku
  784.         //fclose(zapis);
  785.     return 0;
  786. }
RAW Paste Data
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
 
Top