Advertisement
Guest User

Untitled

a guest
Dec 14th, 2019
148
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 37.58 KB | None | 0 0
  1. //Dominika Piotrowska 180311 ID2
  2. //Project 1 – card game
  3.  
  4. #include<iostream>
  5. #include<ctime>
  6. #include <unistd.h>
  7.  
  8. using namespace std;
  9.  
  10. #define FILE_AVERAGE "average.txt"
  11. #define FILE_WINS "numberOfWins.txt"
  12. #define FILE_AVERAGE_2 "average2.txt"
  13.  
  14. #define SLEEP_TIME 0
  15.  
  16. #define MAX_SIZE_OF_DECK 52
  17. #define NUMBER_OF_COLORS 4
  18. #define NUMBER_OF_FIGURES 13
  19. const char CLUBS[] = { "\xe2\x99\xa3" };
  20. const char DIAMONDS[] = { "\xe2\x97\x86" };
  21. const char HEARTS[] = { "\xe2\x99\xa5" };
  22. const char SPADES[] = { "\xe2\x99\xa0" };
  23.  
  24. struct card {
  25. char rank;
  26. char color[4];
  27. unsigned short value;
  28. unsigned short valueColor;
  29. };
  30.  
  31. struct player {
  32. card deck[MAX_SIZE_OF_DECK]{};
  33. int numberOfWins = 0;
  34. int numberOfCards = 0;
  35. void (*strategy)(player&, player&) = nullptr;
  36.  
  37. };
  38.  
  39. void zeroing(card array[]);
  40. int choosingVariant(char variant);
  41. void initialization(int sizeOfDeck, card deck[]);
  42. void shuffling(int sizeOfDeck, card deck[]);
  43. int check(int pomValue, int pomValueColor, card deck[], int i);
  44. void dealingCards(int sizeOfDeck, card deck[], player& player1, player& player2);
  45. void initialHands(player& player1, player& player2);
  46. void battle(int sizeOfDeck, player& player1, player& player2, int isVariantA, int& sumOfMovements, card randomDeck[], int isSmartwar);
  47. void warSmartWar(int sizeOfDeck, player& player1, player& player2, card deck1[], card deck2[], int& counter, int& numberOfMovements, int isVariantA, card randomDeck[], int isSmartWar);
  48. void randomStrategy(player& currentPlayer, player& secondPlayer);
  49. void furiousStrategy(player& furiousPlayer, player& secondPlayer);
  50. void peacefulStrategy(player& peacefulPlayer, player& secondPlayer);
  51. void winningRandom(player& winningPlayer, player& losingPlayer);
  52. void randomAdding(player& winningPlayer, player& losingPlayer, int counter, card randomDeck[]);
  53. void variantA(int sizeOfDeck, player& player1, player& player2, card deck1[], card deck2[], int counter, int isVariantA, int& numberOfMovements, card randomDeck[], int isSmartWar);
  54. void variantB(player& winningPlayer, player& losingPlayer, int& counter);
  55. void moving(player& currentPlayer);
  56. void clear(player& currentPlayer, int number);
  57. void winning(player& winningPlayer, player& losingPlayer);
  58. void war(int sizeOfDeck, player& player1, player& player2, card deck1[], card deck2[], int& counter, int isVariantA, int& numberOfMovements, int& counterHelp, card randomDeck[], int isSmartWar);
  59. void movingWar(player& winningPlayer, player& losingPlayer, int counter);
  60. void displayWar(player& player1, player& player2, card deck1[], card deck2[]);
  61. void endingWar(player& player1, player& player2, card deck1[], card deck2[], int counter, int isVariantA, card randomDeck[], int isSmartWar);
  62. void battleSmartWar(int sizeOfDeck, player& player1, player& player2, int isVariantA, int& sumOfMovements, card randomDeck[], int isSmartWar);
  63. void ending(player& player1, player& player2, int numberOfMovements, int& sumOfMovements);
  64. void choosePlayerStrategy(player&);
  65. int valueOfStartingDeck(card* deck, int sizeOfDeck);
  66. int main()
  67. {
  68.  
  69.  
  70. card deck[MAX_SIZE_OF_DECK];
  71. card randomDeck[MAX_SIZE_OF_DECK];
  72. zeroing(randomDeck);
  73. srand(time(NULL));
  74.  
  75.  
  76. player player1;
  77. player player2;
  78. player1.numberOfWins = 0;
  79. player2.numberOfWins = 0;
  80. int sizeOfDeck = 0;
  81. char variant = 0;
  82. int sumOfMovements = 0;
  83. int option = 1;
  84. cout << "What do you want to do?" << endl;
  85. cout << "1. Demonstrate a simulation of a game. " << endl;
  86. cout << "2. Experiment 1. Simulate war game for x times and save to the file average number of movements." << endl;
  87. cout << "3. Experiment 1. Smart war game simulations." << endl;
  88. cout << "4. Experiment 2. Smart war game strategies." << endl;
  89. cout << "5. Experiment 2. Correlation." << endl;
  90. cout << "You choose option ";
  91. cin >> option;
  92. if (option != 4)//in option 4 size of deck must be 52
  93. {
  94. cout << "Choose size of deck: ";
  95. cin >> sizeOfDeck;
  96. }
  97. int isVariantA = 0;
  98. int isSmartWar = 0;
  99. if (option == 1 || option == 2||option==5)
  100. {
  101. cout << "Choose one of two possible variants of the game." << endl;
  102. cout << "A . If a player runs out of cards during a war he immediately loses." << endl;
  103. cout << "B . If a player (say X) runs out of cards during a war, then:" << endl << "1) if X starting the war had only one card, then his opponent (sayY) is placing two cards on X’s stack, then two cards on Y’s," << endl << "2) if X starting the war had two cards, then his opponent Y is placing one card on X’s stack, then one card on Y’s," << endl << "3) if Y runs of cards while playing, then X is loosing." << endl;
  104. cout << "You choose: ";
  105. cin >> variant;
  106. isVariantA = choosingVariant(variant);
  107. }
  108. if (option == 1)
  109. {
  110. initialization(sizeOfDeck, deck);
  111. dealingCards(sizeOfDeck, deck, player1, player2);
  112. battle(sizeOfDeck, player1, player2, isVariantA, sumOfMovements,randomDeck,isSmartWar);
  113. }
  114. else if (option == 2)
  115. {
  116. int numberOfGames = 0;
  117. cout << "How many times do you want to simulate this game?" << endl;
  118. cout << "You choose ";
  119. cin >> numberOfGames;
  120. for (int i = 0; i < numberOfGames; i++)
  121. {
  122. zeroing(player1.deck);
  123. zeroing(player2.deck);
  124. initialization(sizeOfDeck, deck);
  125. dealingCards(sizeOfDeck, deck, player1, player2);
  126. battle(sizeOfDeck, player1, player2, isVariantA, sumOfMovements, randomDeck, isSmartWar);
  127. }
  128. cout << endl << "Player1 won " << player1.numberOfWins << " times";
  129. cout << endl << "Player2 won " << player2.numberOfWins << " times";
  130. cout << endl << "IN " << numberOfGames << " GAMES " << sumOfMovements << " WERE MADE.";
  131. FILE* average = fopen(FILE_AVERAGE, "a");
  132. int averageOfMovements = sumOfMovements / numberOfGames;
  133.  
  134. fprintf(average, "average movements %d\n", averageOfMovements);
  135. fprintf(average, "size of deck %d\n", sizeOfDeck);
  136. fprintf(average, "variant %c\n", variant);
  137. fclose(average);
  138. cout << endl << "AVERAGE NUMBER OF MOVEMENTS PER GAME " << averageOfMovements << endl;
  139.  
  140. }
  141. else if (option == 3)
  142. {
  143. int numberOfGames = 0;
  144. cout << "How many times do you want to simulate this game?" << endl;
  145. cout << "You choose ";
  146. cin >> numberOfGames;
  147. isVariantA = 1;
  148. isSmartWar = 1;
  149. player1.strategy = randomStrategy;
  150. player2.strategy = randomStrategy;
  151.  
  152. for (int i = 0; i < numberOfGames; i++)
  153. {
  154. zeroing(player1.deck);
  155. zeroing(player2.deck);
  156. initialization(sizeOfDeck, deck);
  157. dealingCards(sizeOfDeck, deck, player1, player2);
  158. battleSmartWar(sizeOfDeck, player1, player2, isVariantA, sumOfMovements, randomDeck, isSmartWar);
  159. }
  160. cout << endl << "Player1 won " << player1.numberOfWins << " times";
  161. cout << endl << "Player2 won " << player2.numberOfWins << " times";
  162. cout << endl << "IN " << numberOfGames << " GAMES " << sumOfMovements << "WERE MADE.";
  163. FILE* average2 = fopen(FILE_AVERAGE_2, "a");
  164. int averageOfMovements = sumOfMovements / numberOfGames;
  165.  
  166. fprintf(average2, "average movements %d\n", averageOfMovements);
  167. fprintf(average2, "size of deck %d\n", sizeOfDeck);
  168. fclose(average2);
  169. cout << endl << "AVERAGE NUMBER OF MOVEMENTS PER GAME" << averageOfMovements << endl;
  170.  
  171. }
  172. else if (option == 4)
  173. {
  174.  
  175. isVariantA = 1;
  176. isSmartWar = 1;
  177. sizeOfDeck = 52;
  178. cout << "Choose strategy for 1 Player: " << endl;
  179. cout << "1.Random." << endl;
  180. cout << "2.Furious." << endl;
  181. cout << "3.Peaceful." << endl;
  182. choosePlayerStrategy(player1);
  183.  
  184. cout << "Choose strategy for 2 Player: " << endl;
  185. cout << "1.Random." << endl;
  186. cout << "2.Furious." << endl;
  187. cout << "3.Peaceful." << endl;
  188. choosePlayerStrategy(player2);
  189.  
  190.  
  191. int numberOfGames = 0;
  192. cout << "How many times do you want to simulate this game?" << endl;
  193. cout << "You choose ";
  194. cin >> numberOfGames;
  195. for (int i = 0; i < numberOfGames; i++)
  196. {
  197. zeroing(player1.deck);
  198. zeroing(player2.deck);
  199. initialization(sizeOfDeck, deck);
  200. dealingCards(sizeOfDeck, deck, player1, player2);
  201. battleSmartWar(sizeOfDeck, player1, player2, isVariantA, sumOfMovements, randomDeck, isSmartWar);
  202.  
  203. }
  204. cout << endl << "Player1 won " << player1.numberOfWins << " times";
  205. cout << endl << "Player2 won " << player2.numberOfWins << " times";
  206. FILE* wins = fopen(FILE_WINS, "a");
  207.  
  208. fprintf(wins, "player 1 wins %d\n", player1.numberOfWins);
  209. fprintf(wins, "player 2 wins %d\n", player2.numberOfWins);
  210.  
  211. fprintf(wins, "strategy player 1 ");
  212. if (player1.strategy == randomStrategy)
  213. fprintf(wins, "RANDOM\n");
  214. else if (player1.strategy == furiousStrategy)
  215. fprintf(wins, "FURIOUS\n");
  216. else
  217. fprintf(wins, "PEACEFUL\n");
  218.  
  219. fprintf(wins, "strategy player 2 ");
  220. if (player2.strategy == randomStrategy)
  221. fprintf(wins, "RANDOM\n");
  222. else if (player2.strategy == furiousStrategy)
  223. fprintf(wins, "FURIOUS\n");
  224. else
  225. fprintf(wins, "PEACEFUL\n");
  226. fclose(wins);
  227. }
  228. else if (option == 5)
  229. {
  230.  
  231. initialization(sizeOfDeck, deck);
  232. dealingCards(sizeOfDeck, deck, player1, player2);
  233. cout << "p1 deck value: " << valueOfStartingDeck(player1.deck, sizeOfDeck) << endl;
  234. cout << "p2 deck value: " << valueOfStartingDeck(player2.deck, sizeOfDeck) << endl;
  235. battle(sizeOfDeck, player1, player2, isVariantA, sumOfMovements, randomDeck, isSmartWar);
  236.  
  237. }
  238.  
  239.  
  240. return 0;
  241.  
  242. }
  243.  
  244. int choosingVariant(char variant)
  245. {
  246. int option = 0;
  247. switch (variant)
  248. {
  249. case 'A':
  250. option = 1;
  251. break;
  252. case 'B':
  253. option = 0;
  254. break;
  255. default:
  256. break;
  257. }
  258. return option;
  259. }
  260.  
  261. void initialization(int sizeOfDeck, card deck[])
  262. {
  263. zeroing(deck);
  264. shuffling(sizeOfDeck, deck);
  265. for (int i = 0; i < sizeOfDeck; i++)
  266. {
  267. if (deck[i].value < 9)
  268. {
  269. deck[i].rank = (deck[i].value + 49);
  270. }
  271. else
  272. {
  273. switch (deck[i].value)
  274. {
  275. case 9:
  276. deck[i].rank = 'X';
  277. break;
  278. case 10:
  279. deck[i].rank = 'J';
  280. break;
  281. case 11:
  282. deck[i].rank = 'Q';
  283. break;
  284. case 12:
  285. deck[i].rank = 'K';
  286. break;
  287. case 13:
  288. deck[i].rank = 'A';
  289. break;
  290. }
  291. }
  292. switch (deck[i].valueColor)
  293. {
  294. case 1:
  295. strcpy(deck[i].color, CLUBS);
  296. break;
  297. case 2:
  298. strcpy(deck[i].color, DIAMONDS);
  299. break;
  300. case 3:
  301. strcpy(deck[i].color, HEARTS);
  302. break;
  303. case 4:
  304. strcpy(deck[i].color, SPADES);
  305. break;
  306. }
  307. }
  308. }
  309.  
  310. int check(int pomValue, int pomValueColor, card deck[], int i)//check if such a card is already in the deck
  311. {
  312. for (int index = 0; index < i; index++)
  313. {
  314. if (pomValue == deck[index].value && pomValueColor == deck[index].valueColor)
  315. {
  316. return 1;
  317. }
  318. }
  319. deck[i].value = pomValue;
  320. deck[i].valueColor = pomValueColor;
  321. return 0;
  322. }
  323.  
  324. void shuffling(int sizeOfDeck, card deck[])
  325. {
  326.  
  327. for (int i = 0; i < sizeOfDeck; i++)
  328. {
  329. int pomValue;
  330. int pomValueColor;
  331. do {
  332. pomValue = rand() % (sizeOfDeck / NUMBER_OF_COLORS) + (NUMBER_OF_FIGURES - sizeOfDeck / NUMBER_OF_COLORS + 1);
  333. pomValueColor = rand() % (NUMBER_OF_COLORS)+1;
  334. } while (check(pomValue, pomValueColor, deck, i));
  335. }
  336. }
  337.  
  338. void dealingCards(int sizeOfDeck, card deck[], player& player1, player& player2)
  339. {
  340. player1.numberOfCards = sizeOfDeck / 2;
  341. player2.numberOfCards = sizeOfDeck / 2;
  342. for (int i = 0; i < sizeOfDeck; i++)
  343. {
  344. if (i < (sizeOfDeck / 2))
  345. {
  346. player1.deck[i] = deck[i];
  347. }
  348. else
  349. {
  350. player1.deck[i].value = 0;
  351. player1.deck[i].valueColor = 0;
  352. player1.deck[i].rank = 0;
  353. strcpy(player1.deck[i].color, "");
  354. }
  355. }
  356. for (int i = 0; i < sizeOfDeck; i++)
  357. {
  358. if (i < sizeOfDeck / 2)
  359. {
  360. player2.deck[i] = deck[i + (sizeOfDeck / 2)];
  361. }
  362. else
  363. {
  364. player2.deck[i].value = 0;
  365. player2.deck[i].valueColor = 0;
  366. player2.deck[i].rank = 0;
  367. strcpy(player2.deck[i].color, "");
  368. }
  369. }
  370. }
  371. void initialHands(player& player1, player& player2)
  372. {
  373. cout << "----------------------------------------------" << endl;
  374. cout << "----------------------------------------------" << endl;
  375. cout << "Initial hands PLAYER 1" << endl << endl;
  376. for (int i = 0; i < player1.numberOfCards; i++)
  377. {
  378. cout << "PLAYER1 [" << i << "]\t\t" << player1.deck[i].rank << player1.deck[i].color << endl;
  379. }
  380. cout << "----------------------------------------------" << endl;
  381. cout << "----------------------------------------------" << endl;
  382. cout << "Initial hands PLAYER 2" << endl << endl;
  383. for (int i = 0; i < player2.numberOfCards; i++)
  384. {
  385. cout << "PLAYER2 [" << i << "]\t\t" << player2.deck[i].rank << player2.deck[i].color << endl;
  386. }
  387. }
  388. void battleSmartWar(int sizeOfDeck, player& player1, player& player2, int isVariantA, int& sumOfMovements,card randomDeck[],int isSmartWar)
  389. {
  390. int numberOfMovements = 0;
  391. int numberOfChoicesMade = 0;
  392.  
  393. initialHands(player1, player2);
  394. while (player1.numberOfCards != 0 && player2.numberOfCards != 0)
  395. {
  396. numberOfMovements++;
  397. numberOfChoicesMade++;
  398. if (numberOfChoicesMade % 2 == 0)
  399. {
  400. cout << endl << "PLAYER 1\t \t";
  401. cout << "PLAYER 2" << endl;
  402. cout << player1.deck[0].rank << player1.deck[0].color <<" | "<< player1.deck[1].rank << player1.deck[1].color << "\t \t \t";
  403. cout << player2.deck[0].rank << player2.deck[0].color << endl;
  404. player1.strategy(player1, player2);
  405. }
  406. else
  407. {
  408. cout << endl << "PLAYER 1\t \t";
  409. cout << "PLAYER 2" << endl;
  410. cout << player1.deck[0].rank << player1.deck[0].color << "\t \t \t \t";
  411. cout << player2.deck[0].rank << player2.deck[0].color << " | " << player2.deck[1].rank << player2.deck[1].color << endl;
  412. player2.strategy(player2, player1);
  413. }
  414. cout << endl << "PLAYER 1\t \t";
  415. cout << "PLAYER 2" << endl;
  416. cout << player1.deck[0].rank << player1.deck[0].color << "\t \t \t \t";
  417. cout << player2.deck[0].rank << player2.deck[0].color << endl;
  418. sleep(SLEEP_TIME);
  419. if (player1.deck[0].value > player2.deck[0].value)
  420. {
  421. winningRandom(player1, player2);
  422. cout << "Player 1 won a battle." << endl;
  423. }
  424. else if (player1.deck[0].value < player2.deck[0].value)
  425. {
  426. winningRandom(player2, player1);
  427. cout << "Player 2 won a battle." << endl;
  428. }
  429. else//WAR
  430. {
  431. cout << endl << " WAR" << endl << endl;
  432.  
  433. if (player1.numberOfCards < 3 || player2.numberOfCards < 3)
  434. {
  435. if (player1.numberOfCards > player2.numberOfCards)
  436. {
  437. player1.numberOfCards = player1.numberOfCards + player2.numberOfCards;
  438. player2.numberOfCards = 0;
  439. }
  440. else
  441. {
  442. player2.numberOfCards = player2.numberOfCards + player1.numberOfCards;
  443. player1.numberOfCards = 0;
  444. }
  445. }
  446. else
  447. {
  448. numberOfMovements++;
  449. int counter = 1;
  450. player1.numberOfCards = player1.numberOfCards - 3;//they can lose 3 cards
  451. player2.numberOfCards = player2.numberOfCards - 3;
  452. warSmartWar(sizeOfDeck, player1, player2, player1.deck+2, player2.deck+2, counter, numberOfMovements, isVariantA, randomDeck, isSmartWar);
  453. }
  454. }
  455.  
  456.  
  457. }
  458. ending(player1, player2, numberOfMovements, sumOfMovements);
  459. }
  460.  
  461. void randomStrategy(player& currentPlayer, player& secondPlayer)//choosing one of two cards
  462. {
  463. if (currentPlayer.numberOfCards == 1) return;
  464. int i=0;
  465. i = rand() % 2;
  466. if (i == 1)
  467. {
  468. card pomCard = currentPlayer.deck[i];
  469. currentPlayer.deck[i] = currentPlayer.deck[i - 1];
  470. currentPlayer.deck[i - 1] = pomCard;
  471. }
  472. }
  473.  
  474. void furiousStrategy(player& furiousPlayer, player &secondPlayer)
  475. {
  476. if (furiousPlayer.deck[1].value == secondPlayer.deck[0].value)
  477. {
  478. card pomCard = furiousPlayer.deck[1];
  479. furiousPlayer.deck[1] = furiousPlayer.deck[0];
  480. furiousPlayer.deck[0] = pomCard;
  481. }
  482. else if (furiousPlayer.deck[0].value > secondPlayer.deck[0].value)
  483. {
  484. if (furiousPlayer.deck[1].value > secondPlayer.deck[0].value && furiousPlayer.deck[1].value<furiousPlayer.deck[0].value)
  485. {
  486. card pomCard = furiousPlayer.deck[1];
  487. furiousPlayer.deck[1] = furiousPlayer.deck[0];
  488. furiousPlayer.deck[0] = pomCard;
  489. }
  490.  
  491. }
  492. else if (furiousPlayer.deck[0].value < secondPlayer.deck[0].value)
  493. {
  494. if (furiousPlayer.deck[1].value > secondPlayer.deck[0].value)
  495. {
  496. card pomCard = furiousPlayer.deck[1];
  497. furiousPlayer.deck[1] = furiousPlayer.deck[0];
  498. furiousPlayer.deck[0] = pomCard;
  499. }
  500. else if (furiousPlayer.deck[1].value < furiousPlayer.deck[0].value)
  501. {
  502. card pomCard = furiousPlayer.deck[1];
  503. furiousPlayer.deck[1] = furiousPlayer.deck[0];
  504. furiousPlayer.deck[0] = pomCard;
  505. }
  506.  
  507. }
  508.  
  509. }
  510.  
  511. void peacefulStrategy(player& peacefulPlayer, player& secondPlayer)
  512. {
  513. if (peacefulPlayer.numberOfCards == 1) return;
  514. else if (peacefulPlayer.deck[0].value < peacefulPlayer.deck[1].value)
  515. {
  516. if (peacefulPlayer.deck[0].value == secondPlayer.deck[0].value)
  517. {
  518. card pomCard = peacefulPlayer.deck[1];
  519. peacefulPlayer.deck[1] = peacefulPlayer.deck[0];
  520. peacefulPlayer.deck[0] = pomCard;
  521. }
  522.  
  523. }
  524. else
  525. if (peacefulPlayer.deck[1].value != secondPlayer.deck[0].value)
  526. {
  527. card pomCard = peacefulPlayer.deck[1];
  528. peacefulPlayer.deck[1] = peacefulPlayer.deck[0];
  529. peacefulPlayer.deck[0] = pomCard;
  530. }
  531. }
  532.  
  533. void winningRandom(player& winningPlayer, player& losingPlayer)//adding cards in random order after winning the battle
  534. {
  535. int i;
  536. i = rand() % 2;
  537.  
  538. card pomWinner = winningPlayer.deck[0];
  539. card pomLoser = losingPlayer.deck[0];
  540. moving(winningPlayer);
  541. winningPlayer.numberOfCards++;
  542. moving(losingPlayer);
  543. losingPlayer.numberOfCards--;
  544. if (i == 1)
  545. {
  546. winningPlayer.deck[winningPlayer.numberOfCards - 2] = pomWinner;
  547. winningPlayer.deck[winningPlayer.numberOfCards - 1] = pomLoser;
  548. }
  549. else
  550. {
  551. winningPlayer.deck[winningPlayer.numberOfCards - 2] = pomLoser;
  552. winningPlayer.deck[winningPlayer.numberOfCards - 1] = pomWinner;
  553. }
  554.  
  555.  
  556. }
  557.  
  558. void randomAdding(player& winningPlayer, player& losingPlayer, int counter, card randomDeck[])//creating a table with cards which should go to winners hand in random order
  559. {
  560. int index = 0;
  561. for (int i = 0; i < ((counter * 2) + 1); i++)
  562. {
  563. do
  564. {
  565. index = rand() % (2 * ((counter * 2) + 1));
  566. } while (randomDeck[index].value != 0);
  567.  
  568. randomDeck[index]= winningPlayer.deck[0];
  569. moving(winningPlayer);
  570. winningPlayer.numberOfCards--;
  571. }
  572.  
  573. for (int i = 0; i < ((counter * 2) + 1); i++)
  574. {
  575. do
  576. {
  577. index = rand() % (2 * ((counter * 2) + 1));
  578. } while (randomDeck[index].value != 0);
  579.  
  580. randomDeck[index]= losingPlayer.deck[0];
  581. moving(losingPlayer);
  582. losingPlayer.numberOfCards--;
  583. }
  584.  
  585. for (int i = 0; i < (2 * ((counter * 2) + 1)); i++)
  586. {
  587. winningPlayer.deck[winningPlayer.numberOfCards + i] = randomDeck[i];
  588. }
  589.  
  590. zeroing(randomDeck);
  591. winningPlayer.numberOfCards = winningPlayer.numberOfCards + (2 * ((counter * 2) + 1));
  592. }
  593.  
  594. void warSmartWar(int sizeOfDeck, player& player1, player& player2, card deck1[], card deck2[], int& counter, int& numberOfMovements, int isVariantA, card randomDeck[],int isSmartWar)
  595. {
  596. if (deck1[0].value == deck2[0].value)
  597. {
  598. counter++;
  599. numberOfMovements++;
  600. if (player1.numberOfCards <= 1 || player2.numberOfCards <= 1)
  601. {
  602.  
  603. endingWar(player1, player2, deck1, deck2, counter, isVariantA, randomDeck, isSmartWar);
  604.  
  605. }
  606. else
  607. {
  608. displayWar(player1, player2, deck1, deck2);
  609. cout << endl << " WAR" << endl << endl;
  610. player1.numberOfCards = player1.numberOfCards - 2;//player can lose 2 cards
  611. player2.numberOfCards = player2.numberOfCards - 2;
  612. warSmartWar(sizeOfDeck, player1, player2, deck1 + 2, deck2 + 2, counter, numberOfMovements,isVariantA,randomDeck,isSmartWar );
  613. }
  614.  
  615. }
  616. else if (player1.numberOfCards < 0)
  617. {
  618. player1.numberOfCards = 0;
  619. player2.numberOfCards = sizeOfDeck;
  620. }
  621. else if (player2.numberOfCards < 0)
  622. {
  623. player2.numberOfCards = 0;
  624. player1.numberOfCards = sizeOfDeck;
  625. }
  626. else
  627. {
  628. endingWar(player1, player2, deck1, deck2, counter, isVariantA,randomDeck,isSmartWar);
  629. }
  630.  
  631. }
  632.  
  633.  
  634. void battle(int sizeOfDeck, player& player1, player& player2, int isVariantA, int& sumOfMovements,card randomDeck[],int isSmartWar)
  635. {
  636. int numberOfMovements = 0;
  637.  
  638. initialHands(player1, player2);
  639. while (player1.numberOfCards != 0 && player2.numberOfCards != 0)
  640. {
  641. int counterHelp = 0;
  642. numberOfMovements++;
  643. cout << endl << "PLAYER 1 \t \t";
  644. cout << "PLAYER 2" << endl;
  645. cout << player1.deck[0].rank << player1.deck[0].color << "\t \t \t \t";
  646. cout << player2.deck[0].rank << player2.deck[0].color << endl;
  647. sleep(SLEEP_TIME);
  648. if (player1.deck[0].value > player2.deck[0].value)
  649. {
  650. winning(player1, player2);
  651. cout << "Player 1 won a battle." << endl;
  652. }
  653. else if (player1.deck[0].value < player2.deck[0].value)
  654. {
  655. winning(player2, player1);
  656. cout << "Player 2 won a battle." << endl;
  657. }
  658. else//WAR
  659. {
  660. cout << endl << " WAR" << endl << endl;
  661. if (isVariantA)
  662. {
  663. if (player1.numberOfCards < 3 || player2.numberOfCards < 3)
  664. {
  665. if (player1.numberOfCards > player2.numberOfCards)
  666. {
  667. player1.numberOfCards = player1.numberOfCards + player2.numberOfCards;
  668. player2.numberOfCards = 0;
  669. }
  670. else
  671. {
  672. player2.numberOfCards = player2.numberOfCards + player1.numberOfCards;
  673. player1.numberOfCards = 0;
  674. }
  675. }
  676. else
  677. {
  678. numberOfMovements++;
  679. int counter = 1;
  680. player1.numberOfCards = player1.numberOfCards - 3;//player can lose 3 cards
  681. player2.numberOfCards = player2.numberOfCards - 3;
  682. war(sizeOfDeck, player1, player2, player1.deck + 2, player2.deck + 2, counter, isVariantA, numberOfMovements, counterHelp,randomDeck,isSmartWar);
  683. }
  684. }
  685. else//VariantB
  686. {
  687. int counter = 1;
  688. if (player1.numberOfCards == 1 || player1.numberOfCards == 2)
  689. {
  690. if (player1.numberOfCards == 1)
  691. numberOfMovements++;
  692. counterHelp++;
  693. variantB(player2, player1, counter);
  694. }
  695. else if (player2.numberOfCards == 1 || player2.numberOfCards == 2)
  696. {
  697. if (player2.numberOfCards == 1)
  698. numberOfMovements++;
  699. counterHelp++;
  700. variantB(player1, player2, counter);
  701. }
  702. player1.numberOfCards = player1.numberOfCards - 3;
  703. player2.numberOfCards = player2.numberOfCards - 3;
  704. war(sizeOfDeck, player1, player2, player1.deck + 2, player2.deck + 2, counter, isVariantA, numberOfMovements, counterHelp, randomDeck, isSmartWar);
  705.  
  706. }
  707.  
  708. }
  709. }
  710.  
  711. if (player1.numberOfCards > player2.numberOfCards)
  712. player1.numberOfCards = player1.numberOfCards + player2.numberOfCards;
  713. else
  714. player2.numberOfCards = player2.numberOfCards + player1.numberOfCards;
  715. ending(player1, player2, numberOfMovements, sumOfMovements);
  716. }
  717.  
  718. void ending(player& player1, player& player2, int numberOfMovements, int& sumOfMovements)
  719. {
  720. cout << "THE END" << endl;
  721. if (player1.numberOfCards == 0 && player2.numberOfCards != 0)
  722. {
  723. cout << "PLAYER 1 HAS LOST ALL CARDS" << endl;
  724. cout << "PLAYER 2 IS A WINNER";
  725. player2.numberOfWins++;
  726. }
  727. else if (player2.numberOfCards == 0 && player1.numberOfCards != 0)
  728. {
  729. cout << "PLAYER 2 HAS LOST ALL CARDS" << endl;
  730. cout << "PLAYER 1 IS A WINNER";
  731. player1.numberOfWins++;
  732. }
  733. else
  734. cout << "DRAW";
  735. cout << endl << numberOfMovements << " MOVEMENTS WERE MADE ";
  736. sumOfMovements = sumOfMovements + numberOfMovements;
  737. }
  738.  
  739. void choosePlayerStrategy(player &player)
  740. {
  741. int option = 1;
  742. cin >> option;
  743. switch (option) {
  744. case 1:
  745. player.strategy = randomStrategy;
  746. break;
  747. case 2:
  748. player.strategy = furiousStrategy;
  749. break;
  750. case 3:
  751. player.strategy = peacefulStrategy;
  752. break;
  753. default:
  754. break;
  755. }
  756.  
  757.  
  758. }
  759.  
  760.  
  761. void winning(player& winningPlayer, player& losingPlayer)//adding cards to winners hand
  762. {
  763. card pomWinner = winningPlayer.deck[0];
  764. card pomLoser = losingPlayer.deck[0];
  765. moving(winningPlayer);
  766. winningPlayer.numberOfCards++;
  767. moving(losingPlayer);
  768. losingPlayer.numberOfCards--;
  769. winningPlayer.deck[winningPlayer.numberOfCards - 2] = pomWinner;
  770. winningPlayer.deck[winningPlayer.numberOfCards - 1] = pomLoser;
  771.  
  772. }
  773.  
  774. void moving(player& currentPlayer)
  775. {
  776. for (int i = 0; i < currentPlayer.numberOfCards - 1; i++)
  777. {
  778. currentPlayer.deck[i] = currentPlayer.deck[i + 1];
  779. }
  780. clear(currentPlayer, 1);
  781.  
  782. }
  783.  
  784. void movingWar(player& winningPlayer, player& losingPlayer, int counter)
  785. {
  786. for (int i = 0; i < ((counter * 2) + 1); i++)
  787. {
  788. card pomWinner = winningPlayer.deck[0];
  789. moving(winningPlayer);
  790. winningPlayer.numberOfCards++;
  791. winningPlayer.deck[winningPlayer.numberOfCards - 2 - i] = pomWinner;
  792. }
  793. for (int i = 0; i < ((counter * 2) + 1); i++)
  794. {
  795. card pomLoser = losingPlayer.deck[0];
  796. moving(losingPlayer);
  797. losingPlayer.numberOfCards--;
  798. winningPlayer.deck[winningPlayer.numberOfCards - (counter * 2 + 1 - i)] = pomLoser;
  799.  
  800. }
  801. }
  802.  
  803. void war(int sizeOfDeck, player& player1, player& player2, card deck1[], card deck2[], int& counter, int isVariantA, int& numberOfMovements, int& counterHelp,card randomDeck[],int isSmartWar)
  804. {
  805.  
  806. if (!isVariantA)
  807. numberOfMovements++;
  808. if (deck1[0].value == deck2[0].value)
  809. {
  810. counter++;
  811. if (isVariantA)
  812. {
  813. variantA(sizeOfDeck, player1, player2, deck1, deck2, counter, isVariantA, numberOfMovements, randomDeck, isSmartWar);
  814. }
  815. else//VariantB
  816. {
  817.  
  818. if (player2.numberOfCards == 0 && counterHelp == 1)
  819. {
  820. displayWar(player1, player2, deck1, deck2);
  821. cout << "Player 1 won a war." << endl;
  822. }
  823. else if (player1.numberOfCards == 0 && counterHelp == 1)
  824. {
  825.  
  826. displayWar(player1, player2, deck1, deck2);
  827. cout << "Player 2 won a war." << endl;
  828. }
  829. else if (player1.numberOfCards == 0 || player1.numberOfCards == 1 || player2.numberOfCards == 0 || player2.numberOfCards == 1)
  830. {
  831. numberOfMovements++;
  832. if (player1.numberOfCards == 0 || player1.numberOfCards == 1)
  833. {
  834. if (player1.numberOfCards == 0)
  835. numberOfMovements++;
  836. player1.numberOfCards++;
  837. variantB(player2, player1, counter);
  838. player1.numberOfCards--;
  839. }
  840. else if (player2.numberOfCards == 0 || player2.numberOfCards == 1)
  841. {
  842.  
  843. if (player2.numberOfCards == 0)
  844. numberOfMovements++;
  845. player2.numberOfCards++;
  846. variantB(player1, player2, counter);
  847. player2.numberOfCards--;
  848. }
  849.  
  850. displayWar(player1, player2, deck1, deck2);
  851. cout << endl << " WAR" << endl << endl;
  852. player1.numberOfCards = player1.numberOfCards - 2;
  853. player2.numberOfCards = player2.numberOfCards - 2;
  854. war(sizeOfDeck, player1, player2, deck1 + 2, deck2 + 2, counter, isVariantA, numberOfMovements, counterHelp, randomDeck, isSmartWar);
  855.  
  856. }
  857.  
  858. else
  859. {
  860. displayWar(player1, player2, deck1, deck2);
  861. cout << endl << " WAR" << endl << endl;
  862. player1.numberOfCards = player1.numberOfCards - 2;
  863. player2.numberOfCards = player2.numberOfCards - 2;
  864. war(sizeOfDeck, player1, player2, deck1 + 2, deck2 + 2, counter, isVariantA, numberOfMovements, counterHelp, randomDeck, isSmartWar);
  865. }
  866. }
  867. }
  868. else if (player1.numberOfCards < 0)
  869. {
  870. player1.numberOfCards = 0;
  871. player2.numberOfCards = sizeOfDeck;
  872. }
  873. else if (player2.numberOfCards < 0)
  874. {
  875. player2.numberOfCards = 0;
  876. player1.numberOfCards = sizeOfDeck;
  877. }
  878. else
  879. {
  880. endingWar(player1, player2, deck1, deck2, counter, isVariantA,randomDeck,isSmartWar);
  881. }
  882.  
  883. }
  884.  
  885. void displayWar(player& player1, player& player2, card deck1[], card deck2[])
  886. {
  887. cout << endl << "PLAYER 1\t \t";
  888. cout << "PLAYER 2" << endl;
  889. cout << deck1[0].rank << deck1[0].color << "\t \t \t \t";
  890. cout << deck2[0].rank << deck2[0].color << endl;
  891. sleep(SLEEP_TIME);
  892. }
  893.  
  894. void variantA(int sizeOfDeck, player& player1, player& player2, card deck1[], card deck2[], int counter, int isVariantA, int& numberOfMovements,card randomDeck[],int isSmartWar)
  895. {
  896. numberOfMovements++;
  897. if (player1.numberOfCards <= 1 || player2.numberOfCards <= 1)
  898. {
  899. endingWar(player1, player2, deck1, deck2, counter, isVariantA, randomDeck, isSmartWar);
  900. }
  901. else
  902. {
  903. displayWar(player1, player2, deck1, deck2);
  904. cout << endl << " WAR" << endl << endl;
  905. player1.numberOfCards = player1.numberOfCards - 2;
  906. player2.numberOfCards = player2.numberOfCards - 2;
  907. war(sizeOfDeck, player1, player2, deck1 + 2, deck2 + 2, counter, isVariantA, numberOfMovements, counter,randomDeck,isSmartWar);
  908. }
  909. }
  910.  
  911. void clear(player& currentPlayer, int number)
  912. {
  913. currentPlayer.deck[currentPlayer.numberOfCards - number].value = 0;
  914. currentPlayer.deck[currentPlayer.numberOfCards - number].valueColor = 0;
  915. currentPlayer.deck[currentPlayer.numberOfCards - number].rank = 0;
  916. strcpy(currentPlayer.deck[currentPlayer.numberOfCards - number].color, "");
  917. }
  918.  
  919. void variantB(player& winningPlayer, player& losingPlayer, int& counter)
  920. { if (losingPlayer.numberOfCards == 1){
  921. if (counter == 1){
  922. losingPlayer.deck[1] = winningPlayer.deck[1];
  923. losingPlayer.deck[2] = winningPlayer.deck[2];
  924. for (int i = 1; i < (winningPlayer.numberOfCards - 2); i++)
  925. winningPlayer.deck[i] = winningPlayer.deck[i + 2];
  926. clear(winningPlayer, 1);
  927. clear(winningPlayer, 2);
  928. losingPlayer.numberOfCards = losingPlayer.numberOfCards + 2;
  929. winningPlayer.numberOfCards = winningPlayer.numberOfCards - 2;
  930. }
  931. else{
  932. losingPlayer.deck[counter * 2 - 1] = winningPlayer.deck[counter * 2 - 1];
  933. losingPlayer.deck[counter * 2] = winningPlayer.deck[counter * 2];
  934. for (int i = counter * 2; i < (winningPlayer.numberOfCards + 2); i++)
  935. winningPlayer.deck[i - 1] = winningPlayer.deck[i + 1];
  936. clear(winningPlayer, -1);
  937. clear(winningPlayer, -2);
  938. losingPlayer.numberOfCards = losingPlayer.numberOfCards + 2;
  939. winningPlayer.numberOfCards = winningPlayer.numberOfCards - 2;
  940. }
  941. }
  942. else if (losingPlayer.numberOfCards == 2){
  943. if (counter == 1){
  944. losingPlayer.deck[2] = winningPlayer.deck[2];
  945. for (int i = 1; i < (winningPlayer.numberOfCards - 2); i++)
  946. winningPlayer.deck[i + 1] = winningPlayer.deck[i + 2];
  947. clear(winningPlayer, 1);
  948. losingPlayer.numberOfCards = losingPlayer.numberOfCards + 1;
  949. winningPlayer.numberOfCards = winningPlayer.numberOfCards - 1;
  950. }
  951. else{
  952. losingPlayer.deck[counter * 2] = winningPlayer.deck[counter * 2];
  953. for (int i = counter * 2; i < (winningPlayer.numberOfCards + 2); i++)
  954. winningPlayer.deck[i] = winningPlayer.deck[i + 1];
  955. clear(winningPlayer, -2);
  956. losingPlayer.numberOfCards = losingPlayer.numberOfCards + 1;
  957. winningPlayer.numberOfCards = winningPlayer.numberOfCards - 1;
  958. }
  959. }
  960.  
  961. }
  962. void endingWar(player& player1, player& player2, card deck1[], card deck2[], int counter, int isVariantA, card randomDeck[], int isSmartWar)
  963. {
  964. if (deck1[0].value > deck2[0].value){
  965. player1.numberOfCards = player1.numberOfCards + (2 * counter + 1);
  966. player2.numberOfCards = player2.numberOfCards + (2 * counter + 1);
  967. displayWar(player1, player2, deck1, deck2);
  968. if (isSmartWar) {
  969. randomAdding(player1, player2, counter, randomDeck);
  970. }
  971. else
  972. movingWar(player1, player2, counter);
  973. cout << "Player 1 won a war." << endl;
  974. }
  975. else if (deck1[0].value < deck2[0].value){
  976. player1.numberOfCards = player1.numberOfCards + (2 * counter + 1);
  977. player2.numberOfCards = player2.numberOfCards + (2 * counter + 1);
  978. displayWar(player1, player2, deck1, deck2);
  979. if (isSmartWar) {
  980. randomAdding(player2, player1, counter, randomDeck);
  981. }
  982. else
  983. movingWar(player2, player1, counter);
  984. cout << "Player 2 won a war." << endl;
  985. }
  986. else if (deck1[0].value == deck2[0].value && isVariantA){
  987. displayWar(player1, player2, deck1, deck2);
  988. if (player1.numberOfCards > player2.numberOfCards){
  989. cout << "Player 1 won a war." << endl;
  990. player2.numberOfCards = 0;
  991. }
  992. else if (player1.numberOfCards < player2.numberOfCards){
  993. cout << "Player 2 won a war." << endl;
  994. player1.numberOfCards = 0;
  995. }
  996. else if ((player1.numberOfCards == 0 && player2.numberOfCards == 0) || (player1.numberOfCards == 1 && player2.numberOfCards == 1)){
  997. player1.numberOfCards = 0;
  998. player2.numberOfCards = 0;
  999. cout << "DRAW";
  1000. }
  1001.  
  1002. }
  1003. }
  1004.  
  1005.  
  1006. void zeroing(card array[])
  1007. {
  1008. for (int i = 0; i < MAX_SIZE_OF_DECK; i++) {
  1009. strcpy(array[i].color, "");
  1010. array[i].rank = 0;
  1011. array[i].value = 0;
  1012. array[i].valueColor = 0;
  1013. }
  1014. }
  1015.  
  1016.  
  1017. int valueOfStartingDeck(card* deck, int sizeOfDeck)
  1018. {
  1019. int value = 0;
  1020. for (int i = 0; i < sizeOfDeck / 2; i++)
  1021. {
  1022. int cardValue = deck[i].value;
  1023. if (cardValue != 0)
  1024. {
  1025. if ((sizeOfDeck / NUMBER_OF_COLORS) % 2 == 1)
  1026. value += cardValue + (sizeOfDeck - MAX_SIZE_OF_DECK) / (2 * NUMBER_OF_COLORS) - 7;
  1027. else {
  1028.  
  1029. if (cardValue < ((MAX_SIZE_OF_DECK - 4 - sizeOfDeck) / (2 * NUMBER_OF_COLORS) + 8))
  1030. value += cardValue + (sizeOfDeck - (MAX_SIZE_OF_DECK - 4)) / (2 * NUMBER_OF_COLORS) - 8;
  1031. else
  1032. value += cardValue + (sizeOfDeck - (MAX_SIZE_OF_DECK - 4)) / (2 * NUMBER_OF_COLORS) - 7;
  1033. }
  1034. }
  1035. }
  1036. return value;
  1037. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement