API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Dec 8th, 2019
113
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 25.75 KB | None | 0 0
raw download clone embed print report
  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. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!