Guest User

Untitled

a guest
Dec 8th, 2019
71
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