API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Dec 13th, 2019
116
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 26.95 KB | None | 0 0
raw download clone embed print report
  1. #include <stdio.h>
  2. #include <time.h>
  3. #include <stdlib.h>
  4. #include <iostream>
  5.  
  6. using namespace std;
  7.  
  8. #define CARD_TEST
  9. #define TRUE 1
  10. #define FALSE 0
  11.  
  12.  
  13. enum T_cardColour {
  14. BLANK,//warość potrzebna do zainicjowania kart w razie, gdyby jakaś strategia nie została przewidziana
  15. HEART,
  16. DIAMOND,
  17. CLUB,
  18. SPADE
  19. };
  20.  
  21. enum T_cardValue {
  22. ZERO,//warość potrzebna do zainicjowania kart w razie, gdyby jakaś strategia nie została przewidziana
  23. TWO,
  24. THREE,
  25. FOUR,
  26. FIVE,
  27. SIX,
  28. SEVEN,
  29. EIGHT,
  30. NINE,
  31. TEN,
  32. JACK,
  33. QUEEN,
  34. KING,
  35. ACE
  36. };
  37.  
  38. enum T_strategy {
  39. NONE,
  40. RANDOM,
  41. PEACEFUL,
  42. AGRESSIVE
  43. };
  44.  
  45. typedef struct card {
  46. T_cardColour colour;
  47. T_cardValue value;
  48. }T_card;
  49.  
  50. typedef struct hand {
  51. T_card my_card;
  52. struct hand* next_card;
  53. }T_hand;
  54.  
  55. struct player {
  56. T_hand hand_start;
  57. T_hand* hand_bottom;
  58. T_card* table;
  59. int moves_left;//ile maksymalnie ruchów gracz może wykonać w danej rundzie, jeżeli przekroczy tą wartość rozgrywka jest uznana za nieskończoną
  60. int versionB = FALSE;
  61. T_strategy strategy=NONE;
  62. int chooser;
  63. int martial_law=FALSE;
  64. };
  65.  
  66.  
  67.  
  68. #ifdef CARD_TEST
  69. void PrintCard(const T_card printed_card);
  70. void ShuffleCards(T_card* allcards, const int number_of_cards);
  71. #endif
  72.  
  73.  
  74. void CreateNewHand(player* P) {
  75. P->hand_start.next_card = NULL;
  76. }
  77.  
  78.  
  79.  
  80. void ReturnToHand(player* P, const T_card new_card) {
  81. T_hand* beggining = &(P->hand_start);
  82. T_hand* x = (T_hand*)malloc(sizeof(T_hand));
  83. if (x == NULL) {
  84. cout << "There is to little space for this element" << endl;
  85. }
  86. else {
  87. x->my_card = new_card;
  88. x->next_card = beggining->next_card;
  89. beggining->next_card = x;
  90. }
  91. }
  92.  
  93.  
  94.  
  95. void AddToHand(player* P, const T_card new_card) {
  96. T_hand* x = (T_hand*)malloc(sizeof(T_hand));
  97. if (x == NULL) {
  98. cout << "There is to little space for this element" << endl;
  99. }
  100. else {
  101.  
  102. x->my_card = new_card;
  103. x->next_card = P->hand_bottom->next_card;
  104. P->hand_bottom->next_card = x;
  105.  
  106. while (P->hand_bottom->next_card != NULL) {
  107. P->hand_bottom = P->hand_bottom->next_card;
  108. }
  109. }
  110. }
  111.  
  112.  
  113.  
  114. T_card RemoveFromHand(player* P) {
  115. if (P->hand_start.next_card != NULL) {
  116. T_hand* x = P->hand_start.next_card;
  117. P->hand_start.next_card = P->hand_start.next_card->next_card;
  118. T_card removed_card;
  119. removed_card = x->my_card;
  120. free(x);
  121.  
  122. if (P->hand_start.next_card == NULL) {//jeżeli gracz wyłożył swoją ostatnią kartę to hand_bottom znowu musi pokazywać na head
  123. P->hand_bottom = &P->hand_start;
  124. }
  125. return removed_card;
  126. }
  127. }
  128.  
  129.  
  130.  
  131. T_card* CreateCards(const int number_of_cards) {
  132. T_card* all_cards = (T_card*)malloc(number_of_cards * sizeof(T_card));
  133. if (all_cards == NULL) {
  134. cout << "There is to little space for this element" << endl;
  135. return NULL;
  136. }
  137. else {
  138. #ifdef CARD_TEST
  139. cout << endl;
  140. cout << "CREATE CARDS FUNCTION" << endl;
  141. #endif
  142. for (int i = 0; i < number_of_cards; i++) {
  143. T_cardValue value=ZERO;
  144. if (i < 4) { value = ACE; }
  145. else if (i < 8) { value = KING; }
  146. else if (i < 12) { value = QUEEN; }
  147. else if (i < 16) { value = JACK; }
  148. else if (i < 20) { value = TEN; }
  149. else if (i < 24) { value = NINE; }
  150. else if (i < 28) { value = EIGHT; }
  151. else if (i < 32) { value = SEVEN; }
  152. else if (i < 36) { value = SIX; }
  153. else if (i < 40) { value = FIVE; }
  154. else if (i < 44) { value = FOUR; }
  155. else if (i < 48) { value = THREE; }
  156. else if (i < 52) { value = TWO; }
  157.  
  158. T_cardColour colour=BLANK;
  159. if (i % 4 == 0) { colour = HEART; }
  160. else if (i % 4 == 1) { colour = DIAMOND; }
  161. else if (i % 4 == 2) { colour = CLUB; }
  162. else if (i % 4 == 3) { colour = SPADE; }
  163.  
  164. all_cards[i].colour = colour;
  165. all_cards[i].value = value;
  166.  
  167. #ifdef CARD_TEST
  168. PrintCard(all_cards[i]);
  169. #endif
  170. }
  171. return all_cards;
  172. }
  173. }
  174.  
  175.  
  176.  
  177. void Deal(player* P1, player* P2, T_card* allcards, const int number_of_cards) {//podzielenie kart na dwie polowy i zrobienie nich dwoch list, przypisanie listy do gracza
  178. for (int i = 0; i < number_of_cards; i++) {
  179. T_card assigned_card = allcards[i];
  180. if (i <= (number_of_cards / 2) - 1) {
  181. AddToHand(P1, assigned_card);
  182. }
  183. else
  184. AddToHand(P2, assigned_card);
  185. }
  186. }
  187.  
  188.  
  189.  
  190. void ShuffleCards(T_card* allcards, const int number_of_cards) { //potasowanie kart
  191. for (int i = number_of_cards - 1; i > 0; i--) {
  192. int j = rand() % (i + 1);
  193. T_card temp = allcards[i];
  194. allcards[i] = allcards[j];
  195. allcards[j] = temp;
  196. }
  197. #ifdef CARD_TEST
  198. cout << endl;
  199. cout << "SHUFFLE CARDS FUNCTION" << endl;
  200. for (int i = 0; i < number_of_cards; i++) {
  201. PrintCard(allcards[i]);
  202. }
  203. cout << endl;
  204. #endif
  205. }
  206.  
  207.  
  208.  
  209. void HandOfCards(player* P1, player* P2, T_card* allcards, const int number_of_cards) {
  210. ShuffleCards(allcards, number_of_cards);
  211. P1->hand_bottom = &P1->hand_start;//przypisanie wskażnika na głowę i potem uzywamy tego wsk na dodawanie elementów
  212. P2->hand_bottom = &P2->hand_start;//na koniec listy, a head zawsze pokazuje na pierwszy element
  213. Deal(P1, P2, allcards, number_of_cards);
  214. }
  215.  
  216.  
  217.  
  218. void FirstHandOfCards(player* P1, player* P2, const int number_of_cards) {
  219. CreateNewHand(P1);
  220. CreateNewHand(P2);
  221. T_card* allcards = CreateCards(number_of_cards);
  222. HandOfCards(P1, P2, allcards, number_of_cards);
  223. free(allcards);
  224. }
  225.  
  226.  
  227.  
  228. void PrintCard(const T_card printed_card) {
  229. if (printed_card.value == TWO) { cout << "2"; }
  230. else if (printed_card.value == THREE) { cout << "3"; }
  231. else if (printed_card.value == FOUR) { cout << "4"; }
  232. else if (printed_card.value == FIVE) { cout << "5"; }
  233. else if (printed_card.value == SIX) { cout << "6"; }
  234. else if (printed_card.value == SEVEN) { cout << "7"; }
  235. else if (printed_card.value == EIGHT) { cout << "8"; }
  236. else if (printed_card.value == NINE) { cout << "9"; }
  237. else if (printed_card.value == TEN) { cout << "10"; }
  238. else if (printed_card.value == JACK) { cout << "J"; }
  239. else if (printed_card.value == QUEEN) { cout << "Q"; }
  240. else if (printed_card.value == KING) { cout << "K"; }
  241. else if (printed_card.value == ACE) { cout << "A"; }
  242.  
  243. cout << "|";
  244. if (printed_card.colour == HEART) { cout << "h"; }
  245. else if (printed_card.colour == DIAMOND) { cout << "d"; }
  246. else if (printed_card.colour == CLUB) { cout << "c"; }
  247. else if (printed_card.colour == SPADE) { cout << "s"; }
  248. cout << " ";
  249. }
  250.  
  251.  
  252.  
  253. int CountCards(const player P) {
  254. int number_of_cards = 0;
  255. T_hand* skim = P.hand_start.next_card;
  256. while (skim != NULL) {
  257. number_of_cards++;
  258. skim = skim->next_card;
  259. }
  260. return number_of_cards;
  261. }
  262.  
  263.  
  264.  
  265. void ShowAllCards(const player P) {
  266. #ifdef CARD_TEST
  267. cout << endl;
  268. cout << endl;
  269. cout << endl;
  270. cout << endl;
  271. cout << endl;
  272. cout << "peeped" << endl;
  273. #endif
  274. T_hand* peek = P.hand_start.next_card;
  275. while (peek != NULL) {
  276. PrintCard(peek->my_card);
  277. peek = peek->next_card;
  278. }
  279. }
  280.  
  281.  
  282.  
  283.  
  284.  
  285.  
  286.  
  287.  
  288.  
  289.  
  290.  
  291.  
  292. #include <stdio.h>
  293. #include <stdlib.h>
  294. #include <iostream>
  295. #include "deck.h"
  296.  
  297. using namespace std;
  298.  
  299. //#define VersionBTEST
  300. //#define TEST
  301. #define NO_MORE_CARDS_TO_GIVE -1
  302. #define WIN_P1 1
  303. #define WIN_P2 2
  304. #define DRAW 0
  305. #define INFINITE -1
  306.  
  307.  
  308. int InitiatingBattle(player* P1, player* P2,int* crd_nr, int* help);
  309. void Battle(player* P1, player* P2, int* crd_nr, int* help);
  310.  
  311.  
  312. int FunctionCallingCounter() {
  313. static unsigned int count;
  314. count++;
  315. return count;
  316. }
  317.  
  318.  
  319.  
  320. void CardsForWinner(player* winner, player* looser, const int amount_cards) {
  321. #ifdef TEST
  322. cout << "CardsForWinner FUNCTION--> cards_from_winner-->";
  323. for (int i = 0; i < amount_cards /2; i++) {
  324. PrintCard(winner->table[i]);
  325. }
  326. cout << endl;
  327. cout << "CardsForWinner FUNCTION--> cards_from_looser-->";
  328. for (int i = 0; i < amount_cards /2; i++) {
  329. PrintCard(looser->table[i]);
  330. }
  331. cout << endl;
  332. cout << endl;
  333. #endif
  334. if (winner->strategy != NONE) {
  335. if (amount_cards > 3) {
  336. int quantity = amount_cards / 2;
  337. ShuffleCards(winner->table, quantity);
  338. ShuffleCards(looser->table, quantity);
  339. }
  340. }
  341.  
  342. for (int i = 0; i < amount_cards / 2; i++) {
  343. T_card assigned_card = winner->table[i];
  344. AddToHand(winner, assigned_card);
  345. }
  346. free(winner->table);
  347. winner->table = NULL;
  348.  
  349. for (int i = 0; i < amount_cards / 2; i++) {
  350. T_card assigned_card = looser->table[i];
  351. AddToHand(winner, assigned_card);
  352. }
  353. free(looser->table);
  354. looser->table = NULL;
  355. }
  356.  
  357.  
  358.  
  359. T_card* AddToTable(T_card* table, const T_card card_to_add, const int nr_of_cards_on_table) {
  360. FunctionCallingCounter();
  361. //T_card* increased_table = (T_card*)realloc(table, (sizeof(T_card)) * ((nr_of_cards_on_table / 2) + 1));
  362. T_card* increased_table = (T_card*)malloc((sizeof(T_card)) * ((nr_of_cards_on_table / 2) + 1));
  363. #ifdef TEST
  364. cout << endl;
  365. cout << "AddToTable FUNCTION--> table-->";
  366. if (nr_of_cards_on_table == 0 || nr_of_cards_on_table == 1) {
  367. cout << "0" << endl;
  368. }
  369. else {
  370. for (int i = 0; i < nr_of_cards_on_table/2; i++) {
  371. PrintCard(table[i]);
  372. }
  373. cout << endl;
  374. }
  375. cout << "Card to add--> ";
  376. PrintCard(card_to_add);
  377. #endif
  378.  
  379. if (increased_table == NULL) {
  380. cout << "There is to little space for this element" << endl;
  381. return NULL;//zkonczenie gry
  382. }
  383. else {
  384. for (int i = 0; i < nr_of_cards_on_table / 2; i++) {
  385. increased_table[i].value = table[i].value;
  386. increased_table[i].colour = table[i].colour;
  387. }
  388.  
  389. increased_table[nr_of_cards_on_table / 2].value = card_to_add.value;
  390. increased_table[nr_of_cards_on_table / 2].colour = card_to_add.colour;
  391. #ifdef TEST
  392. cout << endl;
  393. cout << "AddToTable FUNCTION--> increased_table-->";
  394. for (int i = 0; i < nr_of_cards_on_table/2 + 1; i++) {
  395. PrintCard(increased_table[i]);
  396. }
  397. cout << endl;
  398. #endif
  399. free(table);
  400. table = NULL;
  401. return increased_table;
  402. }
  403. }
  404.  
  405.  
  406.  
  407. int OpponentsHelp(player* PTaker, player* PGiver,int crd_nr) {
  408. int nr_of_lacking_cards = 2 - CountCards(*PTaker);
  409. for (int i = 0; i < nr_of_lacking_cards; i++) {
  410. if (PGiver->hand_start.next_card == NULL) {
  411. return NO_MORE_CARDS_TO_GIVE;
  412. }
  413. else if (i == 0) {
  414. T_card given_card = RemoveFromHand(PGiver);
  415. PTaker->table = AddToTable(PTaker->table, given_card, crd_nr++);
  416. }
  417. else if (i == 1) {
  418. T_card given_card = RemoveFromHand(PGiver);
  419. AddToHand(PTaker, given_card);
  420.  
  421. #ifdef VersionBTEST
  422. cout << "OpponentsHelp card given to hand-->";
  423. PrintCard(given_card);
  424. cout << endl;
  425. #endif
  426.  
  427. }
  428. }
  429. #ifdef VersionBTEST
  430. cout << "OpponentsHelp takers table-->";
  431. for (int i = 0; i < crd_nr / 2 + 1; i++) {
  432. PrintCard(*takers_table[i]);
  433. }
  434. cout << endl;
  435. #endif
  436. cout << endl;
  437. cout << "***Opponents help was used!***" << endl;
  438. cout << endl;
  439.  
  440. return nr_of_lacking_cards;
  441. }
  442.  
  443.  
  444.  
  445. T_card RandomSelect(const T_card card1, const T_card card2) {
  446. T_card random;
  447. int j = rand() % 2;
  448. if (j == 0) { random = card1; }
  449. else
  450. random = card2;
  451. return random;
  452. }
  453.  
  454.  
  455.  
  456. T_card Strategy(player* P, const T_card card_op1, const T_card card_op2, T_card opponents_card) {
  457. T_card choosen;
  458. choosen.value = ZERO;
  459. choosen.colour = BLANK;
  460. //if (P->strategy == RANDOM) {}//zawsze random, dlatego brak specyfikacji
  461.  
  462.  
  463. if (P->strategy == PEACEFUL) {
  464. if (card_op1.value < opponents_card.value) {
  465. if (card_op1.value < card_op2.value) { choosen = card_op1; }
  466. else if (card_op1.value > card_op2.value) { choosen = card_op2; }
  467. }
  468. else if (card_op1.value > opponents_card.value) {
  469. if (card_op1.value < card_op2.value) { choosen = card_op1; }
  470. else if (card_op1.value>card_op2.value) {
  471. if (card_op2.value != opponents_card.value) {choosen = card_op2;}
  472. else { choosen = card_op1; }
  473. }
  474. }
  475. else if (card_op1.value == opponents_card.value) {
  476. if (card_op1.value != card_op2.value) { choosen = card_op2; }
  477. }
  478. }
  479.  
  480.  
  481. else if (P->strategy == AGRESSIVE) {
  482. if (card_op1.value < opponents_card.value) {
  483. if (card_op1.value < card_op2.value) {
  484. if (opponents_card.value <= card_op2.value) { choosen = card_op2; }
  485. else if(opponents_card.value > card_op2.value){ choosen = card_op1; }
  486. }
  487. else if (card_op1.value > card_op2.value) { choosen = card_op2; }
  488. }
  489. else if (card_op1.value > opponents_card.value) {
  490. if (card_op1.value < card_op2.value) { choosen = card_op1; }
  491. if (card_op1.value > card_op2.value) {
  492. if (card_op2.value == opponents_card.value) { choosen = card_op2; }
  493. if (card_op2.value < opponents_card.value) { choosen = card_op1; }
  494. }
  495. }
  496. else if (card_op1.value == opponents_card.value) {
  497. if (card_op2.value != opponents_card.value) { choosen = card_op1; }
  498. }
  499. }
  500. if(choosen.value==ZERO || choosen.colour==BLANK){
  501. choosen = RandomSelect(card_op1, card_op2);
  502. }
  503. if (choosen.value == card_op1.value && choosen.colour == card_op1.colour) {
  504. ReturnToHand(P, card_op2);
  505. }
  506. else {
  507. ReturnToHand(P, card_op1);
  508. }
  509.  
  510. return choosen;
  511. }
  512.  
  513.  
  514.  
  515. void War(player* P1, player* P2, int* crd_nr, int* help) {
  516. T_card hidden_card_P1 = RemoveFromHand(P1);
  517. T_card hidden_card_P2 = RemoveFromHand(P2);
  518. P1->table = AddToTable(P1->table, hidden_card_P1, (*crd_nr)++);
  519. P2->table = AddToTable(P2->table, hidden_card_P2, (*crd_nr)++);
  520. --(P1->moves_left);
  521. --(P2->moves_left);
  522. InitiatingBattle(P1, P2,crd_nr, help);
  523. }
  524.  
  525.  
  526.  
  527. void InitiatingWar(player* P1, player* P2,int* crd_nr, int* help) {
  528.  
  529. if (*help == TRUE) {
  530. if (CountCards(*P1) < 2 || CountCards(*P2) < 2) {
  531. int nr_of_given_cards = 0;
  532. player** giver = NULL;
  533. T_card** givers_table = NULL;
  534. *help = FALSE;
  535. if (CountCards(*P1) < 2) {
  536. nr_of_given_cards = OpponentsHelp(P1, P2, *crd_nr);
  537. if (nr_of_given_cards == NO_MORE_CARDS_TO_GIVE) { //ponieważ InitiateBattle uznaje gracza, który nie ma kart za przegranego,
  538. InitiatingBattle(P1, P2,crd_nr, help); //to w tej funkcji zamieniamy kolejność table graczy, żeby wygrał gracz,
  539. } //który pozbył się wszyskich kart kiedy oddawał je na stos przeciwnika
  540. else {
  541. giver = &P2;
  542. givers_table = &(P2->table);
  543. }
  544. }
  545. else if (CountCards(*P2) < 2) {
  546. nr_of_given_cards = OpponentsHelp(P2, P1,*crd_nr);
  547. if (nr_of_given_cards == NO_MORE_CARDS_TO_GIVE) {
  548. InitiatingBattle(P1, P2,crd_nr, help);//tak samo tutaj
  549. }
  550. else {
  551. giver = &P1;
  552. givers_table = &(P1->table);
  553. }
  554. }
  555. if (giver != NULL && givers_table != NULL) {
  556. T_card battle_card = RemoveFromHand(*giver);
  557. *givers_table = AddToTable(*givers_table, battle_card, (*crd_nr)++);
  558. (*crd_nr) += 1;
  559. }
  560. #ifdef VersionBTEST
  561. cout << "InitiatingWar P1 table-->";
  562. for (int i = 0; i < (*crd_nr) / 2; i++) {
  563. PrintCard(table_P1[i]);
  564. }
  565. cout << endl;
  566.  
  567. cout << "InitiatingWar P2 table-->";
  568. for (int i = 0; i < (*crd_nr) / 2; i++) {
  569. PrintCard(table_P2[i]);
  570. }
  571. cout << endl;
  572. #endif
  573. InitiatingBattle(P1, P2,crd_nr, help);
  574. }
  575. else {
  576. War(P1, P2, crd_nr, help);
  577. }
  578. }
  579. else if (*help == FALSE) {
  580. P1->martial_law = TRUE;
  581. P2->martial_law = TRUE;
  582. War(P1, P2, crd_nr, help);
  583. }
  584. else { cout << "!!!Something is really wrong-->wsk_help not working as it should!!!" << endl; }
  585. }
  586.  
  587.  
  588.  
  589. int InitiatingBattle(player* P1, player* P2,int* crd_nr, int* help) {
  590. if ((P1->moves_left)<0||(P2->moves_left)<0) {
  591. return INFINITE;
  592. }
  593. if (P1->hand_start.next_card == NULL && P2->hand_start.next_card == NULL) {//Obydwu graczom skończą się karty -->remis
  594. return DRAW;
  595. }
  596. if (P1->hand_start.next_card == NULL) {//Player2 wygrywa
  597. return WIN_P2;
  598. }
  599. else if (P2->hand_start.next_card == NULL) {//Player1 wygrywa
  600. return WIN_P1;
  601. }
  602.  
  603. T_card battle_card_P1, battle_card_P2;
  604. battle_card_P1.colour = BLANK;
  605. battle_card_P1.value = ZERO;
  606. battle_card_P2.colour = BLANK;
  607. battle_card_P2.value = ZERO;
  608. if (P1->strategy != NONE) {
  609. if (P1->martial_law == FALSE) {
  610. if (P1->chooser != FALSE) { //w tej kolejce wybiera P1
  611. if (CountCards(*P1) < 2) {
  612. battle_card_P1 = RemoveFromHand(P1);
  613. }
  614. else {
  615. battle_card_P2 = RemoveFromHand(P2); //dlatego jako pierwszy kartę wykłada P2
  616.  
  617. T_card option1 = RemoveFromHand(P1);
  618. T_card option2 = RemoveFromHand(P1);
  619. battle_card_P1 = Strategy(P1, option1, option2, battle_card_P2);
  620. }
  621. P1->chooser = FALSE;//w następnej kolejce P1 nie ma prawa wybierać
  622. P2->chooser = TRUE;
  623. }
  624.  
  625. else if (P2->chooser != FALSE) {//w tej kolejce wybiera P2
  626. if (CountCards(*P2) < 2) {//jeżeli gracz ma wybierać, a została mu tylko jedna karta to tak naprawdę nie ma wyboru
  627. battle_card_P2 = RemoveFromHand(P2);
  628. }
  629. else{
  630. battle_card_P1 = RemoveFromHand(P1);
  631.  
  632. T_card option1 = RemoveFromHand(P2);
  633. T_card option2 = RemoveFromHand(P2);
  634. battle_card_P2 = Strategy(P2, option1, option2, battle_card_P1);
  635. }
  636. P1->chooser = TRUE;
  637. P2->chooser = FALSE;//w następnej kolejce znowu wybiera P1
  638. }
  639. }
  640. else {
  641. battle_card_P1 = RemoveFromHand(P1);
  642. battle_card_P2 = RemoveFromHand(P2);
  643. }
  644. }
  645. else {
  646. battle_card_P1 = RemoveFromHand(P1);
  647. battle_card_P2 = RemoveFromHand(P2);
  648. }
  649.  
  650. if (battle_card_P1.colour != BLANK && battle_card_P2.colour != BLANK) {
  651. P1->table = AddToTable(P1->table, battle_card_P1, (*crd_nr)++);
  652. P2->table = AddToTable(P2->table, battle_card_P2, (*crd_nr)++);
  653. --(P1->moves_left);
  654. --(P2->moves_left);
  655. Battle(P1, P2, crd_nr, help);
  656. }
  657. }
  658.  
  659.  
  660.  
  661. void Battle(player* P1, player* P2,int* crd_nr, int* help) {
  662. const T_card battle_card_P1 = P1->table[(*crd_nr) / 2 - 1];
  663. const T_card battle_card_P2 = P2->table[(*crd_nr) / 2 - 1];
  664.  
  665. PrintCard(battle_card_P1);
  666. cout << " vs ";
  667. PrintCard(battle_card_P2);
  668. cout << endl;
  669.  
  670. if (battle_card_P1.value == battle_card_P2.value) {//ta sama value karty
  671. cout << endl;
  672. cout << " ***WAR*** " << endl;
  673. cout << endl;
  674. InitiatingWar(P1, P2,crd_nr, help);
  675. }
  676. else {
  677. if (battle_card_P1.value > battle_card_P2.value) {//P1 ma starszą kartę
  678. CardsForWinner(P1, P2, *crd_nr);
  679. }
  680. else {//P2 ma starszą kartę
  681. CardsForWinner(P2, P1,*crd_nr);
  682. }
  683. if (P1->versionB == TRUE) {
  684. *help = true;
  685. }
  686. P1->martial_law = FALSE;
  687. P2->martial_law = FALSE;
  688. *crd_nr = 0;
  689. InitiatingBattle(P1, P2,crd_nr, help);
  690. }
  691. }
  692.  
  693.  
  694.  
  695.  
  696.  
  697.  
  698.  
  699.  
  700.  
  701.  
  702.  
  703. #include <stdio.h>
  704. #include <time.h>
  705. #include <stdlib.h>
  706. #include <iostream>
  707. #include "wargame.h"
  708.  
  709. using namespace std;
  710.  
  711. #define ROUNDS 40
  712.  
  713. int SelectDecksSize();
  714.  
  715. //---------------------------------------------------RANK CHECK ----------------------------------------------
  716. /*int DetermineCardsRank(const T_card checked_card) {
  717. if (checked_card.value == ACE) { return 12; }
  718. else if (checked_card.value == KING) { return 11; }
  719. else if (checked_card.value == QUEEN) { return 10; }
  720. else if (checked_card.value == JACK) { return 9; }
  721. else if (checked_card.value == TEN) { return 8; }
  722. else if (checked_card.value == NINE) { return 7; }
  723. else if (checked_card.value == EIGHT) { return 6; }
  724. else if (checked_card.value == SEVEN) { return 5; }
  725. else if (checked_card.value == SIX) { return 4; }
  726. else if (checked_card.value == FIVE) { return 3; }
  727. else if (checked_card.value == FOUR) { return 2; }
  728. else if (checked_card.value == THREE) { return 1; }
  729. else { return 0; }
  730. }
  731.  
  732. int CountMaxPoints(const int number_of_cards) {
  733. int max_points = 0;
  734. for (int i = 0; i < (number_of_cards / 2); i++) {
  735. if (i < 4) { max_points += 12; }
  736. else if (i < 8) { max_points += 11; }
  737. else if (i < 12) { max_points += 10; }
  738. else if (i < 16) { max_points += 9; }
  739. else if (i < 20) { max_points += 8; }
  740. else if (i < 24) { max_points += 7; }
  741. else if (i < 28) { max_points += 6; }
  742. }
  743. return max_points;
  744. }
  745.  
  746.  
  747. int CountMinPoints(const int number_of_cards) {
  748. int min_points = 0;
  749. for (int i = number_of_cards / 2; i < number_of_cards; i++) {
  750. if (i < 16) { min_points += 9; }
  751. else if (i < 20) { min_points += 8; }
  752. else if (i < 24) { min_points += 7; }
  753. else if (i < 28) { min_points += 6; }
  754. else if (i < 28) { min_points += 6; }
  755. else if (i < 32) { min_points += 5; }
  756. else if (i < 36) { min_points += 4; }
  757. else if (i < 40) { min_points += 3; }
  758. else if (i < 44) { min_points += 2; }
  759. else if (i < 48) { min_points += 1; }
  760. else if (i < 52) { min_points += 0; }
  761. }
  762. return min_points;
  763. }
  764.  
  765.  
  766. int DetermineHandsRank(const int points, const int number_of_cards) {
  767. int max_points = CountMaxPoints(number_of_cards);
  768. int min_points = CountMinPoints(number_of_cards);
  769. int gap = (max_points - min_points) / 12;
  770. if (points <= min_points + gap) { return 0; }
  771. else if (points <= min_points + 2 * gap) { return 1; }
  772. else if (points <= min_points + 3 * gap) { return 2; }
  773. else if (points <= min_points + 4 * gap) { return 3; }
  774. else if (points <= min_points + 5 * gap) { return 4; }
  775. else if (points <= min_points + 6 * gap) { return 5; }
  776. else if (points <= min_points + 7 * gap) { return 6; }
  777. else if (points <= min_points + 8 * gap) { return 7; }
  778. else if (points <= min_points + 9 * gap) { return 8; }
  779. else if (points <= min_points + 10 * gap) { return 9; }
  780. else if (points <= min_points + 11 * gap) { return 10; }
  781. else if (points < min_points + 12 * gap) { return 11; }
  782. else if (points == max_points) { return 12; }
  783. }
  784.  
  785. int RankCheck(const player Player, const int number_of_cards) {
  786. int cards_rank = 0;
  787. T_hand* peek = Player.hand_start.next_card;
  788. while (peek != NULL) {
  789. cards_rank += DetermineCardsRank(peek->my_card);
  790. peek = peek->next_card;
  791. }
  792. free(peek);
  793. int rank = DetermineHandsRank(cards_rank, number_of_cards);
  794. return rank;
  795. }
  796.  
  797.  
  798. void AddToRanks(int** rank_tab, int winner_rank, int looser_rank) {
  799. ((*rank_tab)[winner_rank])++;
  800. ((*rank_tab)[looser_rank + 1])++;
  801. }
  802.  
  803. void PrintRanks(int* rank_tab) {
  804. for (int i = 0; i < 13; i++) {
  805. cout << "RANK " << i << " -->";
  806. cout << rank_tab[i * 2] << " ";
  807. cout << rank_tab[i * 2 + 1] << " " << endl;
  808. }
  809. cout << endl;
  810. }
  811.  
  812. int* CreateRanksTable() {
  813. int* hand_rank = (int*)malloc(26 * sizeof(int));
  814. if (hand_rank != NULL) {
  815. for (int i = 0; i < 26; i++) {
  816. hand_rank[i] = 0;
  817. }
  818. return hand_rank;
  819. }
  820. else { return NULL; }
  821. }*/
  822. //---------------------------------------------------RANK CHECK ----------------------------------------------
  823.  
  824.  
  825.  
  826. void Clear(player* P1, player* P2) {
  827. free(P1->table);
  828. free(P2->table);
  829.  
  830. while (P1->hand_start.next_card != NULL) {
  831. RemoveFromHand(P1);
  832. }
  833.  
  834. while (P2->hand_start.next_card != NULL) {
  835. RemoveFromHand(P2);
  836. }
  837. }
  838.  
  839.  
  840.  
  841. int GameA(player* player1, player* player2, int* opponents_help, const int number_of_cards) {
  842. player1->table = NULL;
  843. player2->table = NULL;
  844. player1->moves_left = 1200;
  845. player2->moves_left = 1200;
  846. int cards_on_table = 0, gameA_winner = 0;
  847.  
  848. //Rozdanie po raz pierwszy kard + zainicjowanie list graczy
  849. FirstHandOfCards(player1, player2, number_of_cards);//tworzy,tasuje i rozdaje karty
  850. /*int rank1 = RankCheck(*player1, number_of_cards);
  851. int rank2 = RankCheck(*player2, number_of_cards);*/
  852.  
  853. gameA_winner = InitiatingBattle(player1, player2,&cards_on_table, opponents_help);
  854.  
  855. //sprawdzenie czy gameA_winner zwróciło poprawną wartość
  856. if (gameA_winner != DRAW && gameA_winner != INFINITE && gameA_winner != WIN_P1 && gameA_winner != WIN_P2) {
  857. gameA_winner = InitiatingBattle(player1, player2, &cards_on_table, opponents_help);
  858. }
  859. Clear(player1, player2);
  860. //if (gameA_winner == 1) { AddToRanks(rank_table, rank1, rank2); }
  861. //else if (gameA_winner == 2) { AddToRanks(rank_table, rank2, rank1); }
  862.  
  863. return gameA_winner;
  864. }
  865.  
  866.  
  867.  
  868. int GameB(player* player1, player* player2, const int number_of_cards) {
  869. int opponents_help = TRUE;
  870. player1->versionB = TRUE;
  871. player2->versionB = TRUE;
  872. int gameB_winner = GameA(player1, player2, &opponents_help, number_of_cards);
  873. return gameB_winner;
  874. }
  875.  
  876.  
  877.  
  878. T_strategy SelectStrategy() {
  879. char strategy;
  880. cout << "Which strategy do you choose for this player?\n\n A) RANDOM \n B) PEACEFUL \n C) AGRESSIVE" << endl;
  881. cin >> strategy;
  882. if (strategy == 'A' || strategy == 'a') { return RANDOM; }
  883. if (strategy == 'B' || strategy == 'b') { return PEACEFUL; }
  884. if (strategy == 'C' || strategy == 'c') { return AGRESSIVE; }
  885. else {
  886. cout << "Your strategy option is invalid. Try one more time" << endl;
  887. SelectStrategy();
  888. }
  889. }
  890.  
  891.  
  892.  
  893. int GameSmartWar(player* player1, player* player2, int* opponents_help, const int number_of_cards) {
  894. player1->chooser = TRUE;
  895. player2->chooser = FALSE;
  896. int gameSW_winner=0;
  897. return gameSW_winner= GameA(player1,player2,opponents_help,number_of_cards);
  898. }
  899.  
  900.  
  901.  
  902. int SelectDecksSize() {
  903. int number_of_cards;
  904. cout << "What size of deck do you choose?\n\n52 cards(full deck)\n48 cards\n44 cards\n40 cards\n36 cards\n32 cards\n28 cards\n24 cards\n20 cards" << endl;
  905. cin >> number_of_cards;
  906. if (number_of_cards == 52) { return 52; }
  907. else if (number_of_cards == 48) { return 48; }
  908. else if (number_of_cards == 44) { return 44; }
  909. else if (number_of_cards == 40) { return 40; }
  910. else if (number_of_cards == 36) { return 36; }
  911. else if (number_of_cards == 32) { return 32; }
  912. else if (number_of_cards == 28) { return 28; }
  913. else if (number_of_cards == 24) { return 24; }
  914. else if (number_of_cards == 20) { return 20; }
  915. else {
  916. cout << "The size of deck you chose is invalid. Try one more time." << endl;
  917. SelectDecksSize();
  918. }
  919. }
  920.  
  921.  
  922.  
  923. char SelectVersion() {
  924. char game_version;
  925. cout << "Which version of WAR would you like to play?\nA)Normal version\nB)Weird version\nS)Smart War" << endl;
  926. cin >> game_version;
  927. if (game_version == 'A' || game_version == 'a') { return 'A'; }
  928. if (game_version == 'B' || game_version == 'b') { return'B'; }
  929. if (game_version == 'S' || game_version == 's') { return 'S'; }
  930. else {
  931. cout << "Your Game option is invalid. Try one more time" << endl;
  932. SelectVersion();
  933. }
  934. }
  935.  
  936.  
  937.  
  938. int main() {
  939. srand(time(NULL));
  940. player player1, player2;
  941. unsigned long int player1_wins = 0, player2_wins = 0, moves = 0;
  942. int winner = 0, infinite_games=0, draw = 0;
  943. int opponents_help = FALSE;
  944.  
  945. int game_version = SelectVersion();
  946. int number_of_cards = SelectDecksSize();
  947. /*int* ranks_table = CreateRanksTable();
  948. if (ranks_table == NULL) {
  949. cout << "There is no space for ranks_table element" << endl;
  950. return 0;
  951. }*/
  952. if (game_version == 'S') {
  953. cout << "PLAYER 1" << endl;
  954. player1.strategy = SelectStrategy();
  955. cout << "PLAYER 2" << endl;
  956. player2.strategy = SelectStrategy();
  957. }
  958.  
  959. for (int i = 0; i < ROUNDS; i++) {
  960. if (game_version == 'A') { winner = GameA(&player1, &player2, &opponents_help, number_of_cards); }
  961. if (game_version == 'B') { winner = GameB(&player1, &player2, number_of_cards); }
  962. if (game_version == 'S') { winner = GameSmartWar(&player1, &player2, &opponents_help, number_of_cards); }
  963.  
  964. if (winner == WIN_P2) {
  965. player2_wins+=1;
  966. }
  967. else if (winner == WIN_P1) {
  968. player1_wins+=1;
  969. }
  970. else if (winner == DRAW) {
  971. draw+=1;
  972. }
  973. else if (winner == INFINITE) {
  974. infinite_games+=1;
  975. }
  976. }
  977. cout << "Player 1 Won= " << player1_wins << " times" << endl;
  978. cout << "Player 2 Won= " << player2_wins << " times" << endl;
  979. cout << "Draws= " << draw << endl;
  980. cout << "Infinite games " << infinite_games << endl;
  981. moves = (FunctionCallingCounter() - 1) / 2;
  982. cout << "Average of moves= " << moves / ROUNDS << endl;
  983.  
  984. //PrintRanks(ranks_table);
  985.  
  986. return 0;
  987. }
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!