API tools faq
paste
Advertisement
Guest User

Projekt 06.12.19

a guest
Dec 6th, 2019
145
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 26.44 KB | None | 0 0
raw download clone embed print report
  1. #include <iostream>
  2. #include <stdlib.h>
  3. #include <time.h>
  4.  
  5. using namespace std;
  6.  
  7. #define END_GAME true
  8. #define MODE_A 0
  9. #define MODE_B 1
  10. #define PLAYER_1_LOSS -1
  11. #define PLAYER_2_LOSS -2
  12. #define PLAYERS_OOC 0
  13. #define ENDLESS_GAME 10000
  14. #define DISPLAY_GAME 1
  15. #define NO_DISPLAY_GAME 0
  16. #define WAR_A_1_WIN 1
  17. #define WAR_A_2_WIN 2
  18. #define PLAYER_1_WAR_B_FUELED_WIN_WITH_1 3
  19. #define PLAYER_2_WAR_B_FUELED_WIN_WITH_1 4
  20. #define PLAYER_1_WAR_B_FUELED_WIN_WITH_2 5
  21. #define PLAYER_2_WAR_B_FUELED_WIN_WITH_2 6
  22.  
  23. //Struktura karty
  24. struct card
  25. {
  26. int value;
  27. char suit;
  28. };
  29.  
  30. //Funkcja ktora tworzy talie, a potem ja tasuje
  31. struct card* create_deck(int deck_size)
  32. {
  33. int i, j;
  34. struct card* deck;
  35. deck = (struct card*) malloc(deck_size * sizeof(struct card));//Najpierw generacja wybranej talii
  36. if (deck == NULL)
  37. {
  38. cout << "Blad przydzielenia pamieci" << endl;
  39. }
  40. else
  41. {
  42. for (i = 0, j = 14; i < deck_size / 4; i++)
  43. {
  44. deck[i].value = j;
  45. deck[i].suit = 'S';
  46. j--;
  47. }
  48. for (i = 0, j = 14; i < deck_size / 4; i++)
  49. {
  50. deck[i + deck_size / 4].value = j;
  51. deck[i + deck_size / 4].suit = 'C';
  52. j--;
  53. }
  54. for (i = 0, j = 14; i < deck_size / 4; i++)
  55. {
  56. deck[i + deck_size / 2].value = j;
  57. deck[i + deck_size / 2].suit = 'H';
  58. j--;
  59. }
  60. for (i = 0, j = 14; i < deck_size / 4; i++)
  61. {
  62. deck[i + 3 * (deck_size / 4)].value = j;
  63. deck[i + 3 * (deck_size / 4)].suit = 'D';
  64. j--;
  65. }
  66. }
  67. struct card temp;
  68. for (i = deck_size - 1; i >= 0; i--)//przetasowanie stworzonej talii
  69. {
  70. j = rand() % (i + 1);
  71. temp = deck[i];
  72. deck[i] = deck[j];
  73. deck[j] = temp;
  74. }
  75. return deck;
  76. }
  77.  
  78. //Rangi rąk
  79. struct ranks
  80. {
  81. int high_wins;
  82. int medium_wins;
  83. int low_wins;
  84. };
  85.  
  86. //Wygrane, przegrane i remisy graczy
  87. struct game_results
  88. {
  89. int A_wins;
  90. int B_wins;
  91. int draws;
  92. };
  93.  
  94. //Funkcja pomocnicza wyswietlajaca potasowana talie
  95. void display_deck(struct card* deck, int size)
  96. {
  97. int k;
  98. for (k = 0; k < size; k++)
  99. {
  100. if (deck[k].value == 14)
  101. {
  102. cout << 'A' << deck[k].suit << endl;
  103. }
  104. else if (deck[k].value == 13)
  105. {
  106. cout << 'K' << deck[k].suit << endl;
  107. }
  108. else if (deck[k].value == 12)
  109. {
  110. cout << 'Q' << deck[k].suit << endl;
  111. }
  112. else if (deck[k].value == 11)
  113. {
  114. cout << 'J' << deck[k].suit << endl;
  115. }
  116. else
  117. {
  118. cout << deck[k].value << deck[k].suit << endl;
  119. }
  120. }
  121. }
  122.  
  123. //Funkcja wyswietlajaca karte
  124. void display_card(struct card card)
  125. {
  126. if (card.value == 14)
  127. cout << 'A' << ' ' << card.suit;
  128. else if (card.value == 13)
  129. cout << 'K' << ' ' << card.suit;
  130. else if (card.value == 12)
  131. cout << 'Q' << ' ' << card.suit;
  132. else if (card.value == 11)
  133. cout << 'J' << ' ' << card.suit;
  134. else
  135. cout << card.value << ' ' << card.suit;
  136. }
  137.  
  138. //Struktury i funkcje zwiazane z rekami graczy(kolejka FIFO)*
  139. struct hand_card {
  140. struct card card;
  141. struct hand_card* next;
  142. };
  143. struct hand {
  144. struct hand_card* front;
  145. struct hand_card* back;
  146. };
  147.  
  148. //*Dodawanie karty do reki gracza
  149. void add_card_to_hand(struct hand* player_s_hand, struct card card_to_add)
  150. {
  151. struct hand_card* temp = (struct hand_card*)malloc(sizeof(struct hand_card));
  152. if (temp != NULL)
  153. {
  154. temp->card = card_to_add;
  155. temp->next = NULL;
  156. if ((*player_s_hand).back == NULL && (*player_s_hand).front == NULL)
  157. {
  158. (*player_s_hand).front = (*player_s_hand).back = temp;
  159. }
  160. if ((*player_s_hand).back != NULL)
  161. {
  162. (*player_s_hand).back->next = temp;
  163. (*player_s_hand).back = temp;
  164. }
  165. }
  166. }
  167.  
  168. //*Rozdanie kart
  169. void deal_cards(struct hand* hand_1, struct hand* hand_2, struct card* deck, int deck_size)
  170. {
  171. int i;
  172. for (i = 0; i < deck_size / 2; i++)
  173. {
  174. add_card_to_hand(hand_1, deck[i]);
  175. }
  176. for (i; i < deck_size; i++)
  177. {
  178. add_card_to_hand(hand_2, deck[i]);
  179. }
  180. }
  181.  
  182. //*Usuwanie karty z reki gracza
  183. void remove_card_from_hand(struct hand* player_s_hand)
  184. {
  185. struct hand_card* temp = (*player_s_hand).front;
  186. if ((*player_s_hand).front == NULL)
  187. {
  188.  
  189. }
  190. else if ((*player_s_hand).front == (*player_s_hand).back)
  191. {
  192. (*player_s_hand).front = (*player_s_hand).back = NULL;
  193. }
  194. else
  195. {
  196. (*player_s_hand).front = (*player_s_hand).front->next;
  197. free(temp);
  198. }
  199. }
  200.  
  201. //Pokazanie pierwszej karty gracza(funkcja pomocniczna)
  202. void display_hand(struct hand* hand)
  203. {
  204. if (hand->front != NULL)
  205. {
  206. cout << (*hand).front->card.value << (*hand).front->card.suit << endl;
  207. }
  208. else
  209. {
  210. cout << "Brak kart!" << endl;
  211. }
  212. }
  213.  
  214. //Pokazanie bitwy
  215. void display_battle(struct card card_1, struct card card_2)
  216. {
  217. display_card(card_1);
  218. cout << " vs ";
  219. display_card(card_2);
  220. cout << endl;
  221. }
  222.  
  223. //Funkcja pokazująca statystyki
  224. void display_stats(int score_A_wins, int score_B_wins, int score_draws, int move_counter, int simulation, struct ranks ranks_wins)
  225. {
  226. cout << "Wygrane gracza 1: " << score_A_wins << endl;
  227. cout << "Wygrane gracza 2: " << score_B_wins << endl;
  228. cout << "Remisy: " << score_draws << endl;
  229. cout << "Srednia ilosc ruchow: " << move_counter / simulation << endl;
  230. cout << "Wygrane wysokiej reki: " << ranks_wins.high_wins << endl;
  231. cout << "Wygrane sredniej reki: " << ranks_wins.medium_wins << endl;
  232. cout << "Wygrane niskiej reki: " << ranks_wins.low_wins << endl;
  233. }
  234.  
  235. //Liczenie rangi ręki
  236. void count_hand_ranking(struct card* deck, int deck_size, int* hand_1_ranking, int* hand_2_ranking)
  237. {
  238. int i;
  239. for (i = 0; i < deck_size / 2; i++)
  240. *hand_1_ranking += deck[i].value;
  241. for (i; i < deck_size; i++)
  242. *hand_2_ranking += deck[i].value;
  243. return;
  244. }
  245.  
  246. //Dodawanie wygranych rangom
  247. void add_rang_wins()
  248. {
  249.  
  250. }
  251.  
  252. //Rozwiązanie bitwy
  253. void resolve_battle(struct hand* hand_1, struct hand* hand_2)
  254. {
  255. add_card_to_hand(hand_1, hand_1->front->card);
  256. add_card_to_hand(hand_1, hand_2->front->card);
  257. remove_card_from_hand(hand_1);
  258. remove_card_from_hand(hand_2);
  259. }
  260.  
  261. //Funkcja wojny wariant A
  262. int war_A(struct hand_card* front_1, struct hand_card* front_2, int* moves, struct card* stack, int* stack_number, bool display, int* game_moves)
  263. {
  264. if (front_1 == NULL && front_2 == NULL)
  265. return PLAYERS_OOC;
  266. else if (front_1 == NULL || front_2 == NULL)
  267. return PLAYERS_OOC;
  268. if (display != NO_DISPLAY_GAME)
  269. display_battle(front_1->card, front_2->card);
  270. stack[*stack_number] = front_1->card; (*stack_number)++;
  271. stack[*stack_number] = front_2->card; (*stack_number)++;
  272. (*moves)++;
  273. (*game_moves)++;
  274. if (front_1->next == NULL && front_2->next == NULL)
  275. return PLAYERS_OOC;
  276. else if (front_1->next == NULL)
  277. return PLAYER_1_LOSS;
  278. else if (front_2->next == NULL)
  279. return PLAYER_2_LOSS;
  280. else
  281. {
  282. if(display != NO_DISPLAY_GAME)
  283. cout << "Gracze dorzucaja karty na stol" << endl;
  284. stack[*stack_number] = front_1->next->card; (*stack_number)++;
  285. stack[*stack_number] = front_2->next->card; (*stack_number)++;
  286. (*moves)++;
  287. (*game_moves)++;
  288. if (front_1->next->next == NULL && front_2->next->next == NULL)
  289. return PLAYERS_OOC;
  290. else if (front_1->next->next == NULL)
  291. return PLAYER_1_LOSS;
  292. else if (front_2->next->next == NULL)
  293. return PLAYER_2_LOSS;
  294. else
  295. {
  296. if (display != NO_DISPLAY_GAME)
  297. display_battle(front_1->next->next->card, front_2->next->next->card);
  298. stack[*stack_number] = front_1->next->next->card; (*stack_number)++;
  299. stack[*stack_number] = front_2->next->next->card; (*stack_number)++;
  300. (*moves)++;
  301. (*game_moves)++;
  302. if (front_1->next->next->card.value > front_2->next->next->card.value)
  303. return WAR_A_1_WIN;
  304. else if (front_1->next->next->card.value < front_2->next->next->card.value)
  305. return WAR_A_2_WIN;
  306. else
  307. return war_A(front_1->next->next, front_2->next->next, moves, stack, stack_number,display,game_moves);
  308. }
  309. }
  310. }
  311.  
  312. //Funkcja wojny wariant B
  313. int war_B(struct hand_card* front_1, struct hand_card* front_2, int* moves, struct card* stack, int* stack_number, bool display, int* game_moves, bool* player_1_fueled, bool* player_2_fueled)
  314. {
  315. if (front_1 == NULL && front_2 == NULL)
  316. return PLAYERS_OOC;
  317. else
  318. {
  319. if (display != NO_DISPLAY_GAME)
  320. display_battle(front_1->card, front_2->card);
  321. stack[*stack_number] = front_1->card; (*stack_number)++;
  322. stack[*stack_number] = front_2->card; (*stack_number)++;
  323. (*moves)++;
  324. (*game_moves)++;
  325. if (front_1->next == NULL && front_2->next == NULL)
  326. {
  327. return PLAYERS_OOC;
  328. }
  329. else if (front_1->next == NULL && *player_2_fueled == 1)
  330. return PLAYER_2_LOSS;
  331. else if (front_2->next == NULL && *player_1_fueled == 1)
  332. return PLAYER_1_LOSS;
  333. else if (front_1->next == NULL && *player_1_fueled == 1)
  334. return PLAYER_1_LOSS;
  335. else if (front_2->next == NULL && *player_2_fueled == 1)
  336. return PLAYER_2_LOSS;
  337. else if (front_1->next == NULL && *player_1_fueled == 0)//gracz 1 zaczyna wojnę z jedną kartą
  338. {
  339. if (front_2->next->next != NULL && front_2->next->next->next != NULL && front_2->next->next->next->next != NULL)
  340. {
  341. (*player_1_fueled) = 1;
  342. if (display != NO_DISPLAY_GAME)
  343. cout << "Gracz 2 zasila gracza 1 czterema kartami" << endl;
  344. stack[*stack_number] = front_2->next->card; (*stack_number)++;
  345. stack[*stack_number] = front_2->next->next->card; (*stack_number)++;
  346. (*moves)++;
  347. (*game_moves)++;
  348. if (display != NO_DISPLAY_GAME)
  349. display_battle(front_2->next->next->card, front_2->next->next->next->next->card);
  350. stack[*stack_number] = front_2->next->next->next->card; (*stack_number)++;
  351. stack[*stack_number] = front_2->next->next->next->next->card; (*stack_number)++;
  352. (*moves)++;
  353. (*game_moves)++;
  354. if (front_2->next->next->card.value <= front_2->next->next->next->next->card.value)
  355. return PLAYER_1_LOSS;
  356. else
  357. return PLAYER_1_WAR_B_FUELED_WIN_WITH_1;
  358.  
  359. }
  360. else//Graczowi 2 skończą się karty podczas zasilania
  361. return PLAYER_1_LOSS;
  362. }
  363. else if (front_2->next == NULL && *player_2_fueled == 0)//gracz 2 zaczyna wojnę z jedną kartą
  364. {
  365. if (front_1->next->next != NULL && front_1->next->next->next != NULL && front_1->next->next->next->next != NULL)
  366. {
  367. (*player_2_fueled) = 1;
  368. if (display != NO_DISPLAY_GAME)
  369. cout << "Gracz 1 zasila gracza 2 czterema kartami" << endl;
  370. stack[*stack_number] = front_1->next->card; (*stack_number)++;
  371. stack[*stack_number] = front_1->next->next->card; (*stack_number)++;
  372. (*moves)++;
  373. (*game_moves)++;
  374. if (display != NO_DISPLAY_GAME)
  375. display_battle(front_1->next->next->card, front_1->next->next->next->next->card);
  376. stack[*stack_number] = front_1->next->next->next->card; (*stack_number)++;
  377. stack[*stack_number] = front_1->next->next->next->next->card; (*stack_number)++;
  378. (*moves)++;
  379. (*game_moves)++;
  380. if (front_1->next->next->card.value <= front_1->next->next->next->next->card.value)
  381. return PLAYER_2_LOSS;
  382. else
  383. return PLAYER_2_WAR_B_FUELED_WIN_WITH_1;//dodać instrukcję do tego
  384.  
  385. }
  386. else//Graczowi 1 skończą się karty podczas zasilania
  387. return PLAYER_2_LOSS;
  388. }
  389. else
  390. {
  391. if (display != NO_DISPLAY_GAME)
  392. cout << "Gracze dorzucaja karty na stol" << endl;
  393. stack[*stack_number] = front_1->next->card; (*stack_number)++;
  394. stack[*stack_number] = front_2->next->card; (*stack_number)++;
  395. (*moves)++;
  396. (*game_moves)++;
  397. if (front_1->next->next == NULL && front_2->next->next == NULL)
  398. return PLAYERS_OOC;
  399. else if (front_1->next->next == NULL && *player_2_fueled == 1)
  400. return PLAYER_2_LOSS;
  401. else if (front_2->next->next == NULL && *player_1_fueled == 1)
  402. return PLAYER_1_LOSS;
  403. else if (front_1->next->next == NULL && *player_1_fueled == 1)
  404. return PLAYER_1_LOSS;
  405. else if (front_2->next->next == NULL && *player_2_fueled == 1)
  406. return PLAYER_2_LOSS;
  407. else if (front_1->next->next == NULL && *player_1_fueled == 0)//Gracz 1 zaczyna wojnę z dwoma kartami; Gracz 2 zasila gracza 1
  408. {
  409. if (front_2->next->next->next != NULL && front_2->next->next->next->next != NULL)
  410. {
  411. (*player_1_fueled = 1);
  412. if (display != NO_DISPLAY_GAME)
  413. display_battle(front_2->next->next->next->card, front_2->next->next->next->next->card);
  414. stack[*stack_number] = front_2->next->next->next->card; (*stack_number)++;
  415. stack[*stack_number] = front_2->next->next->next->next->card; (*stack_number)++;
  416. (*moves)++;
  417. (*game_moves)++;
  418. if (front_2->next->next->next->card.value <= front_2->next->next->next->next->card.value)
  419. return PLAYER_1_LOSS;
  420. else
  421. return PLAYER_1_WAR_B_FUELED_WIN_WITH_2;//dodać instrukcję do tego
  422. }
  423. else
  424. return PLAYER_1_LOSS;
  425. }
  426. else if (front_2->next->next == NULL && *player_2_fueled == 0)//Gracz 2 zaczyna wojnę z dwoma kartami; Gracz 1 zasila gracza 2
  427. {
  428. if (front_1->next->next->next != NULL && front_1->next->next->next->next !=NULL)
  429. {
  430. (*player_2_fueled = 1);
  431. if (display != NO_DISPLAY_GAME)
  432. display_battle(front_1->next->next->next->card, front_1->next->next->next->next->card);
  433. stack[*stack_number] = front_1->next->next->next->card; (*stack_number)++;
  434. stack[*stack_number] = front_1->next->next->next->next->card; (*stack_number)++;
  435. (*moves)++;
  436. (*game_moves)++;
  437. if (front_1->next->next->next->card.value <= front_1->next->next->next->next->card.value)
  438. return PLAYER_2_LOSS;
  439. else
  440. return PLAYER_2_WAR_B_FUELED_WIN_WITH_2;//dodać instrukcję do tego
  441.  
  442. }
  443. else
  444. return PLAYER_2_LOSS;
  445. }
  446. else
  447. {
  448. if (display != NO_DISPLAY_GAME)
  449. display_battle(front_1->next->next->card, front_2->next->next->card);
  450. stack[*stack_number] = front_1->next->next->card; (*stack_number)++;
  451. stack[*stack_number] = front_2->next->next->card; (*stack_number)++;
  452. (*moves)++;
  453. (*game_moves)++;
  454. if (front_1->next->next->card.value > front_2->next->next->card.value)
  455. return WAR_A_1_WIN;
  456. else if (front_1->next->next->card.value < front_2->next->next->card.value)
  457. return WAR_A_2_WIN;
  458. else
  459. return war_B(front_1->next->next, front_2->next->next, moves, stack, stack_number, display, game_moves, player_1_fueled, player_2_fueled);
  460. }
  461. }
  462.  
  463. }
  464. }
  465.  
  466. //Funkcja obsługująca wyniki wojen
  467. bool result_manager(int result, int stack_number, struct card* stack, struct hand* hand_1, struct hand* hand_2, bool display, int* game_moves, int* A_wins,int* B_wins,int* draws, bool* player_1_fueled, bool* player_2_fueled)
  468. {
  469. int i;
  470. if (result == PLAYERS_OOC)
  471. {
  472. if (display != NO_DISPLAY_GAME)
  473. {
  474. cout << "Remis" << endl;
  475. cout << "Liczba ruchow: " << *game_moves << endl;
  476. }
  477. (*draws)++;
  478. free(stack);
  479. return true;
  480. }
  481. else if (result == PLAYER_1_LOSS)
  482. {
  483. if (display != NO_DISPLAY_GAME)
  484. {
  485. cout << "Wygral gracz Drugi!" << endl;
  486. cout << "Liczba ruchow: " << *game_moves << endl;
  487. }
  488. (*B_wins)++;
  489. free(stack);
  490. return true;
  491. }
  492. else if (result == PLAYER_2_LOSS)
  493. {
  494. if (display != NO_DISPLAY_GAME)
  495. {
  496. cout << "Wygral gracz Pierwszy!" << endl;
  497. cout << "Liczba ruchow: " << *game_moves << endl;
  498. }
  499. (*A_wins)++;
  500. free(stack);
  501. return true;
  502. }
  503. else if (result == WAR_A_1_WIN)//gracz 1 wygrał wojnę
  504. {
  505. for (i = 0; i < stack_number; i++)
  506. {
  507. if (i % 2 == 0)
  508. add_card_to_hand(hand_1, stack[i]);
  509. }
  510. for (i = 0; i < stack_number; i++)
  511. {
  512. if (i % 2 == 1)
  513. add_card_to_hand(hand_1, stack[i]);
  514. }
  515. for (i = 0; i < stack_number / 2; i++)
  516. remove_card_from_hand(hand_1);
  517. for (i = 0; i < stack_number / 2; i++)
  518. remove_card_from_hand(hand_2);
  519. return false;
  520. }
  521. else if (result == WAR_A_2_WIN)//gracz 2 wygrał wojnę
  522. {
  523. for (i = 0; i < stack_number; i++)
  524. {
  525. if (i % 2 == 1)
  526. add_card_to_hand(hand_2, stack[i]);
  527. }
  528. for (i = 0; i < stack_number; i++)
  529. {
  530. if (i % 2 == 0)
  531. add_card_to_hand(hand_2, stack[i]);
  532. }
  533. for (i = 0; i < stack_number / 2; i++)
  534. remove_card_from_hand(hand_1);
  535. for (i = 0; i < stack_number / 2; i++)
  536. remove_card_from_hand(hand_2);
  537. return false;
  538. }
  539. else if (result == PLAYER_1_WAR_B_FUELED_WIN_WITH_1)
  540. {
  541. for (i = 0; i < stack_number - 4; i++)
  542. {
  543. if (i % 2 == 0)
  544. add_card_to_hand(hand_1, stack[i]);
  545. }
  546. for (i = 0; i < stack_number - 4; i++)
  547. {
  548. if (i % 2 == 1)
  549. add_card_to_hand(hand_1, stack[i]);
  550. }
  551. for (i = stack_number - 4; i < stack_number; i++)
  552. add_card_to_hand(hand_1, stack[i]);
  553. for (i = 0; i < (stack_number - 4) / 2; i++)
  554. remove_card_from_hand(hand_1);
  555. for (i = 0; i < ((stack_number - 4) / 2) + 4; i++)
  556. remove_card_from_hand(hand_2);
  557. *player_1_fueled = 0;
  558. return false;
  559. }
  560. else if (result == PLAYER_2_WAR_B_FUELED_WIN_WITH_1)
  561. {
  562. for (i = 0; i < stack_number - 4; i++)
  563. {
  564. if (i % 2 == 1)
  565. add_card_to_hand(hand_2, stack[i]);
  566. }
  567. for (i = 0; i < stack_number - 4; i++)
  568. {
  569. if (i % 2 == 0)
  570. add_card_to_hand(hand_2, stack[i]);
  571. }
  572. for (i = (stack_number - 4); i < stack_number; i++)
  573. add_card_to_hand(hand_2, stack[i]);
  574. for (i = 0; i < (stack_number - 4) / 2; i++)
  575. remove_card_from_hand(hand_2);
  576. for (i = 0; i < ((stack_number - 4) / 2) + 4; i++)
  577. remove_card_from_hand(hand_1);
  578. *player_2_fueled = 0;
  579. return false;
  580. }
  581. else if (result == PLAYER_1_WAR_B_FUELED_WIN_WITH_2)
  582. {
  583. for (i = 0; i < stack_number - 2; i++)
  584. {
  585. if (i % 2 == 0)
  586. add_card_to_hand(hand_1, stack[i]);
  587. }
  588. for (i = 0; i < stack_number - 2; i++)
  589. {
  590. if (i % 2 == 1)
  591. add_card_to_hand(hand_1, stack[i]);
  592. }
  593. for (i = (stack_number - 2); i < stack_number; i++)
  594. add_card_to_hand(hand_1, stack[i]);
  595. for (i = 0; i < (stack_number - 2) / 2; i++)
  596. remove_card_from_hand(hand_1);
  597. for (i = 0; i < ((stack_number - 2) / 2) + 2; i++)
  598. remove_card_from_hand(hand_2);
  599. *player_1_fueled = 0;
  600. return false;
  601. }
  602. else if (result == PLAYER_2_WAR_B_FUELED_WIN_WITH_2)
  603. {
  604. for (i = 0; i < stack_number - 2; i++)
  605. {
  606. if (i % 2 == 1)
  607. add_card_to_hand(hand_2, stack[i]);
  608. }
  609. for (i = 0; i < stack_number - 2; i++)
  610. {
  611. if (i % 2 == 0)
  612. add_card_to_hand(hand_2, stack[i]);
  613. }
  614. for (i = (stack_number - 2); i < stack_number; i++)
  615. add_card_to_hand(hand_2, stack[i]);
  616. for (i = 0; i < (stack_number - 2) / 2; i++)
  617. remove_card_from_hand(hand_2);
  618. for (i = 0; i < ((stack_number - 2) / 2) + 2; i++)
  619. remove_card_from_hand(hand_1);
  620. *player_2_fueled = 0;
  621. return false;
  622. }
  623. }
  624.  
  625. //Funkcja prowadzaca gre; wariant A i B
  626. void game_A(struct hand* hand_1, struct hand* hand_2, int deck_size, int* moves,int* A_wins, int* B_wins,int* draws, bool display , bool mode)
  627. {
  628. int i, game_moves = 0;
  629. struct card* stack;
  630. stack = (struct card*) malloc(104 * sizeof(struct card));
  631. bool player_1_fueled = 0;
  632. bool player_2_fueled = 0;
  633. while ((*hand_1).front != NULL && (*hand_2).front != NULL)
  634. {
  635. if (game_moves >= ENDLESS_GAME)
  636. {
  637. if (display != NO_DISPLAY_GAME)
  638. cout << "Nieskonczona gra - Remis" << endl;
  639. (*draws)++;
  640. free(stack);
  641. return;
  642. }
  643. int stack_number = 0;
  644. if ((*hand_1).front->card.value > (*hand_2).front->card.value)//Jeżeli gracz 1 wygrywa bitwę
  645. {
  646. if (display != NO_DISPLAY_GAME)
  647. display_battle((*hand_1).front->card, (*hand_2).front->card);
  648. resolve_battle(hand_1, hand_2);
  649. (*moves)++;
  650. game_moves++;
  651. }
  652. else if ((*hand_1).front->card.value < (*hand_2).front->card.value)//Jeżeli gracz 2 wygrywa bitwę
  653. {
  654. if (display != NO_DISPLAY_GAME)
  655. display_battle((*hand_1).front->card, (*hand_2).front->card);
  656. resolve_battle(hand_2, hand_1);
  657. (*moves)++;
  658. game_moves++;
  659. }
  660. else
  661. {
  662. int result;
  663. if (mode == MODE_A)
  664. result = war_A(hand_1->front, hand_2->front, moves, stack, &stack_number, display, &game_moves);//Jeżeli dochodzi do wojny 'A'
  665. else
  666. result = war_B(hand_1->front, hand_2->front, moves, stack, &stack_number, display, &game_moves, &player_1_fueled, &player_2_fueled);//Jeżeli dochodzi do wojny 'B'
  667. if (result_manager(result, stack_number, stack, hand_1, hand_2, display, &game_moves, A_wins, B_wins, draws, &player_1_fueled, &player_2_fueled) == END_GAME)
  668. return;
  669.  
  670. }
  671. }
  672. if ((*hand_1).front == NULL)
  673. {
  674. if (display != NO_DISPLAY_GAME)
  675. {
  676. cout << "Wygral gracz Drugi!" << endl;
  677. cout << "Liczba ruchow: " << game_moves << endl;
  678. }
  679. (*B_wins)++;
  680. free(stack);
  681. return;
  682. }
  683. else if ((*hand_2).front == NULL)
  684. {
  685. if (display != NO_DISPLAY_GAME)
  686. {
  687. cout << "Wygral gracz Pierwszy!" << endl;
  688. cout << "Liczba ruchow: " << game_moves << endl;
  689. }
  690. (*A_wins)++;
  691. free(stack);
  692. return;
  693. }
  694.  
  695. }
  696.  
  697.  
  698.  
  699. int main()
  700. {
  701. //Zmienne do wyników
  702. int score_A_wins, score_B_wins, score_draws, hand_1_ranking, hand_2_ranking;
  703. int* score_A_wins_ptr = &score_A_wins;
  704. int* score_B_wins_ptr = &score_B_wins;
  705. int* score_draws_ptr = &score_draws;
  706. bool display;
  707. int move_counter;
  708. int* move_counter_ptr = &move_counter;
  709. struct card* deck_ptr;
  710. struct hand hand_1 = { NULL,NULL };
  711. struct hand hand_2 = { NULL,NULL };
  712. struct hand* hand_1_ptr = &hand_1;
  713. struct hand* hand_2_ptr = &hand_2;
  714. struct ranks ranks_wins = { 0,0,0 };
  715. srand(time(NULL));
  716. int deck_size;
  717. int k;
  718. char choice = 0;
  719. while (choice != 'Q')
  720. {
  721. cout << "----------MENU----------" << endl;//wybór rodzaju wojny
  722. cout << "1. Wojna." << endl;
  723. cout << "2. Madra wojna." << endl;
  724. cout << "Q. Wyjdz z programu" << endl;
  725. cin >> choice;
  726. switch (choice)
  727. {
  728. case '1':
  729. {
  730. cout << "A. Wariant A." << endl;//wybór wariantu gry
  731. cout << "B. Wariant B." << endl;
  732. cin >> choice;
  733. switch (choice)
  734. {
  735. case 'A':
  736. {
  737. cout << "1. Demonstracja gry." << endl;//wybór demonstracji lub symulacji
  738. cout << "2. Symulacja gier." << endl;
  739. cin >> choice;
  740. switch (choice)
  741. {
  742. case '1'://Demonstracja gry
  743. {
  744. cout << "Podaj rozmiar talii(Karty od Asa w dol, ilosc kart podzielna przez 4" << endl;
  745. cin >> deck_size;
  746. if (deck_size % 4 == 0 && deck_size<=52 && deck_size>0)
  747. {
  748. display = DISPLAY_GAME;
  749. score_A_wins = score_B_wins = score_draws = move_counter = hand_1_ranking = hand_2_ranking = 0;
  750. deck_ptr=create_deck(deck_size);
  751. display_deck(deck_ptr, deck_size);
  752. hand_1.front = NULL, hand_1.back = NULL;
  753. hand_2.front = NULL, hand_2.back = NULL;
  754. deal_cards(hand_1_ptr, hand_2_ptr, deck_ptr, deck_size);
  755. cout << "Reka gracza 1:" << endl;
  756. for (k = 0; k < deck_size / 2; k++)
  757. {
  758. display_card(deck_ptr[k]);
  759. cout << " ";
  760. }
  761. cout << endl;
  762. cout << "Reka gracza 2:" << endl;
  763. for (k; k < deck_size; k++)
  764. {
  765. display_card(deck_ptr[k]);
  766. cout << " ";
  767. }
  768. cout << endl;
  769. game_A(hand_1_ptr, hand_2_ptr, deck_size, move_counter_ptr, score_A_wins_ptr, score_B_wins_ptr, score_draws_ptr, display, MODE_A);
  770. }
  771. else
  772. cout << "Niepoprawny rozmiar talii" << endl;
  773. break;
  774. }
  775. case '2'://symulacja gier
  776. {
  777. cout << "Podaj rozmiar talii(Karty od Asa w dol, ilosc kart podzielna przez 4" << endl;
  778. cin >> deck_size;
  779. if (deck_size % 4 == 0 && deck_size <= 52 && deck_size>0)
  780. {
  781. int simulation, a;
  782. display = NO_DISPLAY_GAME;
  783. score_A_wins = score_B_wins = score_draws = move_counter = 0;
  784. struct ranks ranks_wins = { 0,0,0 };
  785. cout << "Podaj ilosc gier, ktore chcesz symulowac" << endl;
  786. cin >> simulation;
  787. for (a = 0; a < simulation; a++)
  788. {
  789. deck_ptr = create_deck(deck_size);
  790. hand_1.front = NULL, hand_1.back = NULL;
  791. hand_2.front = NULL, hand_2.back = NULL;
  792. hand_1_ranking = hand_2_ranking = 0;
  793. deal_cards(hand_1_ptr, hand_2_ptr, deck_ptr, deck_size);
  794. count_hand_ranking(deck_ptr, deck_size, &hand_1_ranking, &hand_2_ranking);
  795. game_A(hand_1_ptr, hand_2_ptr, deck_size, move_counter_ptr, score_A_wins_ptr, score_B_wins_ptr, score_draws_ptr, display, MODE_A);
  796. }
  797. display_stats(score_A_wins, score_B_wins, score_draws, move_counter, simulation, ranks_wins);
  798. }
  799. else
  800. cout << "Niepoprawny rozmiar talii" << endl;
  801. break;
  802. }
  803. }
  804. break;
  805. }
  806. case 'B':
  807. {
  808. cout << "1. Demonstracja gry." << endl;//wybór demonstracji lub symulacji
  809. cout << "2. Symulacja gier." << endl;
  810. cin >> choice;
  811. switch (choice)
  812. {
  813. case '1':
  814. {
  815. cout << "Podaj rozmiar talii(Karty od Asa w dol, ilosc kart podzielna przez 4" << endl;
  816. cin >> deck_size;
  817. if (deck_size % 4 == 0 && deck_size <= 52 && deck_size > 0)
  818. {
  819. display = DISPLAY_GAME;
  820. score_A_wins = score_B_wins = score_draws = move_counter = 0;
  821. deck_ptr = create_deck(deck_size);
  822. display_deck(deck_ptr, deck_size);
  823. hand_1.front = NULL, hand_1.back = NULL;
  824. hand_2.front = NULL, hand_2.back = NULL;
  825. deal_cards(hand_1_ptr, hand_2_ptr, deck_ptr, deck_size);
  826. cout << "Reka gracza 1:" << endl;
  827. for (k = 0; k < deck_size / 2; k++)
  828. {
  829. display_card(deck_ptr[k]);
  830. cout << " ";
  831. }
  832. cout << endl;
  833. cout << "Reka gracza 2:" << endl;
  834. for (k; k < deck_size; k++)
  835. {
  836. display_card(deck_ptr[k]);
  837. cout << " ";
  838. }
  839. cout << endl;
  840. game_A(hand_1_ptr, hand_2_ptr, deck_size, move_counter_ptr, score_A_wins_ptr, score_B_wins_ptr, score_draws_ptr, display, MODE_B);
  841. }
  842. else
  843. {
  844. cout << "Niepoprawny rozmiar talii" << endl;
  845. }
  846. break;
  847. }
  848. case '2':
  849. {
  850. cout << "Podaj rozmiar talii(Karty od Asa w dol, ilosc kart podzielna przez 4" << endl;
  851. cin >> deck_size;
  852. if (deck_size % 4 == 0 && deck_size <= 52 && deck_size > 0)
  853. {
  854. int simulation, a;
  855. display = NO_DISPLAY_GAME;
  856. score_A_wins = score_B_wins = score_draws = move_counter = 0;
  857. struct ranks ranks_wins = { 0,0,0 };
  858. cout << "Podaj ilosc gier, ktore chcesz symulowac" << endl;
  859. cin >> simulation;
  860. for (a = 0; a < simulation; a++)
  861. {
  862. deck_ptr = create_deck(deck_size);
  863. hand_1.front = NULL, hand_1.back = NULL;
  864. hand_2.front = NULL, hand_2.back = NULL;
  865. hand_1_ranking = hand_2_ranking = 0;
  866. deal_cards(hand_1_ptr, hand_2_ptr, deck_ptr, deck_size);
  867. count_hand_ranking(deck_ptr, deck_size, &hand_1_ranking, &hand_2_ranking);
  868. game_A(hand_1_ptr, hand_2_ptr, deck_size, move_counter_ptr, score_A_wins_ptr, score_B_wins_ptr, score_draws_ptr, display, MODE_B);
  869. }
  870. display_stats(score_A_wins, score_B_wins, score_draws, move_counter, simulation, ranks_wins);
  871. }
  872. else
  873. {
  874. cout << "Niepoprawny rozmiar talii" << endl;
  875. }
  876. break;
  877. }
  878. }
  879. break;
  880. }
  881. default:
  882. {
  883. break;
  884. }
  885. }
  886. break;
  887. }
  888. case '2':
  889. {
  890. break;
  891. }
  892. default:
  893. {
  894. break;
  895. }
  896. }
  897. }
  898. return 0;
  899. }
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!