Advertisement
Guest User

Untitled

a guest
Mar 24th, 2018
73
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 11.07 KB | None | 0 0
  1. /*Include statements: Iostream for console input/output, Iomanip for formatting,
  2. cctype for conversion of characters to uppercase,
  3. time.h for importing current system time.*/
  4. #include <iostream>
  5. #include <iomanip>
  6. #include <cctype>
  7. #include <time.h>
  8.  
  9. using namespace std;
  10.  
  11. // function prototypes
  12. char get_mode();
  13. int get_num_players();
  14. char print_menu(char &current_player, bool &quit_flag);
  15. void run_game(char game_board[], int player_positions[], char &current_player, \
  16.     int &current_player_number, bool &quit_flag, char mode, bool &has_chute, \
  17.     bool &has_ladder, int &landing_index, bool &win_flag, bool &hit_flag);
  18. char square_symbol(int pos, char game_board[]);
  19. int generate_roll(char mode);
  20. void move(int roll, int player_positions[], int current_player_number, \
  21.     bool &has_chute, bool &has_ladder, int &landing_index, bool &win_flag);
  22. void activate_ladder();
  23. void activate_chute();
  24. void has_chute_or_ladder(bool &has_chute, bool &has_ladder, int &landing_index, int pos);
  25. void fill_arrays(char game_board[], char game_board_const[]);
  26. void hit_check(int &current_player_number, int player_positions[], int &original_position, bool &hit_flag);
  27.  
  28.  
  29. int main() {
  30.     int num_players, current_player_number, landing_index;
  31.     char player_letter[4] = { 'a','b','c','d', }, game_board[40] = {}, game_board_const[40] = {};
  32.     int player_positions[4] = { -1, -1, -1, -1 }, last_positions[4] = { -1, -1, -1, -1 };
  33.     char mode, user_selection = 'R', current_player, last_symbol = ' ';
  34.     bool quit_flag = false, has_chute, has_ladder, win_flag = false, hit_flag = false;
  35.  
  36.     cout << "-----Chutes and ladders-----\n1, 2 3 go up, and #, $, and ^ go down\n";
  37.  
  38.     num_players = get_num_players();
  39.  
  40.     mode = get_mode();
  41.    
  42.     fill_arrays(game_board, game_board_const);
  43.  
  44.     while (win_flag == false){
  45.         for (int i = 0; i < num_players; i++) {
  46.             current_player = player_letter[i];
  47.             current_player_number = i;
  48.             last_positions[current_player_number] = player_positions[current_player_number];
  49.             run_game(game_board, player_positions, current_player, current_player_number, quit_flag, mode, \
  50.                 has_chute, has_ladder, landing_index, win_flag);
  51.             for (int j = 0; j < num_players; j++) {
  52.                 if (last_positions[j] > -1) {
  53.                     game_board[last_positions[j]] = game_board_copy[last_positions[j]];
  54.                 }
  55.             }
  56.             if (quit_flag == true) {
  57.                 cout << "Quitting...";
  58.                 break;
  59.             }
  60.             if (win_flag == true) {
  61.                 break;
  62.             }
  63.         }
  64.        
  65.  
  66.     }
  67.  
  68.        
  69.     return 0;
  70.    
  71. }
  72.  
  73. void run_game(char game_board[], int player_positions[], char &current_player, \
  74.     int &current_player_number, bool &quit_flag, char mode, bool &has_chute, bool &has_ladder, int &landing_index, \
  75.     bool &win_flag, bool &hit_flag) {
  76.     char current_board_symbol, user_selection;
  77.     int roll;
  78.     for (int i = 1; i < 41; i++) {
  79.         current_board_symbol = square_symbol(i - 1, game_board);
  80.         cout << "| " << current_board_symbol << " ";
  81.         if (i % 8 == 0)
  82.             cout << "|" << endl;
  83.     }
  84.     cout << endl;
  85.     user_selection = print_menu(current_player, quit_flag);
  86.     roll = generate_roll(mode);
  87.     // cout << "\nCurrent player number is: " << current_player_number << endl; // check player numbers
  88.    
  89.     move(roll, player_positions, current_player_number, has_chute, has_ladder, landing_index, win_flag);
  90.     if (player_positions[current_player_number] > -1)
  91.         game_board[player_positions[current_player_number]] = current_player;
  92.    
  93.  
  94.  
  95.  
  96. }
  97.  
  98.  
  99. int get_num_players(){
  100.     int num_players;
  101.     cout << "\nPlease enter how many players there will be: ";
  102.     cin >> num_players;
  103.     if (num_players > 4 || num_players < 2) {
  104.         do {
  105.             cout << "\nPlease enter between 2-4 players: ";
  106.             cin >> num_players;
  107.         } while (num_players > 4 || num_players < 2);
  108.     }
  109.     return num_players;
  110. }
  111.  
  112. char get_mode() {
  113.     char mode = 0;
  114.     cout << "\nChoose which mode to play in \n(D)ebug mode\n(P)ower mode\
  115.             \nAnything else will be regular mode\nEnter Mode: ";
  116.     cin >> mode;
  117.     mode = toupper(mode);
  118.     if (mode != 'D' && mode != 'P')
  119.         mode = 'R';
  120.     return mode;
  121. }
  122.  
  123. char print_menu(char &current_player, bool &quit_flag) {
  124.     char user_selection;
  125.     cout << "----Current player is "<< current_player << "----\n(R)oll\n(Q)uit\n";
  126.     cin >> user_selection;
  127.     user_selection = toupper(user_selection);
  128.  
  129.     if (user_selection != 'Q' && user_selection != 'R') {
  130.         do {
  131.             cout << "\nInvalid Selection!\n(R)oll\n(Q)uit\n";
  132.             cin >> user_selection;
  133.             user_selection = toupper(user_selection);
  134.         } while (user_selection != 'R' && user_selection != 'Q');
  135.     }
  136.  
  137.     if (user_selection == 'Q') {
  138.         quit_flag = true;
  139.     }
  140.    
  141.     return user_selection;
  142. }
  143.  
  144. void fill_arrays(char game_board[], char game_board_const[]) {
  145.     for (int i = 0; i < 40; i++) {
  146.         if (i == 3 || i == 17)
  147.             game_board[i] = '#';
  148.         else if (i == 4 || i == 11)
  149.             game_board[i] = '1';
  150.         else if (i == 6 || i == 27)
  151.             game_board[i] = '2';
  152.         else if (i == 12 || i == 30)
  153.             game_board[i] = '$';
  154.         else if (i == 19 || i == 36)
  155.             game_board[i] = '3';
  156.         else if (i == 26 || i == 35)
  157.             game_board[i] = '%';
  158.         else
  159.             game_board[i] = ' ';
  160.         }
  161.     for (int i = 0; i < 40; i++) {
  162.         game_board_const[i] = game_board[i];
  163.     }
  164.     }
  165.  
  166. char square_symbol(int pos, char game_board[]) {
  167.     char current_symbol;
  168.     if (game_board[pos] == 'a')
  169.         current_symbol = 'a';
  170.     else if (game_board[pos] == 'b')
  171.         current_symbol = 'b';
  172.     else if (game_board[pos] == 'c')
  173.         current_symbol = 'c';
  174.     else if (game_board[pos] == 'd')
  175.         current_symbol = 'd';
  176.     else if (game_board[pos] == ' ')
  177.         current_symbol = ' ';
  178.     else if (game_board[pos] == '1')
  179.         current_symbol = '1';
  180.     else if (game_board[pos] == '2')
  181.         current_symbol = '2';
  182.     else if (game_board[pos] == '3')
  183.         current_symbol = '3';
  184.     else if (game_board[pos] == '%')
  185.         current_symbol = '%';
  186.     else if (game_board[pos] == '#')
  187.         current_symbol = '#';
  188.     else if (game_board[pos] == '$')
  189.         current_symbol = '$';
  190.  
  191.     return current_symbol;
  192. }
  193.  
  194. int generate_roll(char mode) {
  195.     int roll;
  196.     if (mode == 'D') {
  197.         srand(10);
  198.         roll = rand()%6 + 1;
  199.         cout << "\nRolled a " << roll << endl;
  200.  
  201.     }
  202.     else if (mode == 'P') {
  203.         srand(10);
  204.         cout << "\nRoll: ";
  205.         cin >> roll;
  206.     }
  207.     else {
  208.         srand(time(NULL));
  209.         roll = rand()%6 + 1;
  210.         cout << "\nRolled a " << roll << endl;
  211.     }
  212.     return roll;
  213. }
  214.  
  215. void move(int roll, int player_positions[], int current_player_number,\
  216.     bool &has_chute, bool &has_ladder, int &landing_index, bool &win_flag){
  217.     int original_position = player_positions[current_player_number];
  218.     player_positions[current_player_number] += roll;
  219.     has_chute_or_ladder(has_chute, has_ladder, landing_index, player_positions[current_player_number]);
  220.     if (has_chute == true) {
  221.         player_positions[current_player_number] = landing_index;
  222.         activate_chute();
  223.     }
  224.     else if (has_ladder == true) {
  225.         player_positions[current_player_number] = landing_index;
  226.         activate_ladder();
  227.     }
  228.     hit_check(current_player_number, player_positions, original_position);
  229.     if (player_positions[current_player_number] == 40) {
  230.         win_flag = true;
  231.         cout << "Player " << current_player_number + 1 << " wins!\n";
  232.     }
  233.     if (player_positions[current_player_number] > 40) {
  234.         cout << "Rolled past the end of the board. You need an exact roll.\n";
  235.         player_positions[current_player_number] = original_position;
  236.     }
  237.     if (hit_flag == true)
  238.         game_board[player_positions[current_player_number]] = original_position;
  239.    
  240. }
  241.  
  242. void activate_ladder(){
  243.     if (rand() % 2 < 1) {
  244.         cout << "Oh no. You had to climb back up the board.\n";
  245.     }
  246.     else {
  247.         cout << "Climbing up!\n";
  248.     }
  249. }
  250.  
  251. void activate_chute(){
  252.     if (rand() % 2 < 1) {
  253.         cout << "Going down!\n";
  254.     }
  255.     else {
  256.         cout << "Wheeeeeeee!\n";
  257.     }
  258. }
  259.  
  260. void has_chute_or_ladder(bool &has_chute, bool &has_ladder, int &landing_index, int pos){
  261.     if (pos == 11) {
  262.         landing_index = 4;
  263.         has_ladder = true;
  264.     }
  265.     else if (pos == 27) {
  266.         landing_index = 6;
  267.         has_ladder = true;
  268.     }
  269.     else if (pos == 36) {
  270.         landing_index = 19;
  271.         has_ladder = true;
  272.     }
  273.     else if (pos == 3) {
  274.         landing_index = 17;
  275.         has_chute = true;
  276.     }
  277.     else if (pos == 12) {
  278.         landing_index = 30;
  279.         has_chute = true;
  280.     }
  281.     else if (pos == 26) {
  282.         landing_index = 35;
  283.         has_chute = true;
  284.     }
  285.     else {
  286.         has_chute = false;
  287.         has_ladder = false;
  288.     }
  289. }
  290.  
  291. // REWRITE THIS ENTIRE FUNCTION - KILL ME NOW
  292. void hit_check(int &current_player_number, int player_positions[], int &original_position, bool &hit_flag) {
  293.     if (current_player_number == 0) {
  294.         if (player_positions[current_player_number] == player_positions[current_player_number + 1]) {
  295.             cout << "Hit player b" << endl;
  296.             player_positions[current_player_number] = original_position;
  297.             hit_flag = true;
  298.         }
  299.         else if (player_positions[current_player_number] == player_positions[current_player_number + 2]) {
  300.             cout << "Hit player c" << endl;
  301.             player_positions[current_player_number] = original_position;
  302.             hit_flag = true;
  303.         }
  304.         else if (player_positions[current_player_number] == player_positions[current_player_number + 3]) {
  305.             cout << "Hit player d" << endl;
  306.             player_positions[current_player_number] = original_position;
  307.             hit_flag = true;
  308.         }
  309.     }
  310.     else if (current_player_number == 1) {
  311.         if (player_positions[current_player_number] == player_positions[current_player_number - 1]) {
  312.             cout << "Hit player a" << endl;
  313.             player_positions[current_player_number] = original_position;
  314.             hit_flag = true;
  315.         }
  316.         else if (player_positions[current_player_number] == player_positions[current_player_number + 1]) {
  317.             cout << "Hit player c" << endl;
  318.             player_positions[current_player_number] = original_position;
  319.             hit_flag = true;
  320.         }
  321.         else if (player_positions[current_player_number] == player_positions[current_player_number + 2]) {
  322.             cout << "Hit player d" << endl;
  323.             player_positions[current_player_number] = original_position;
  324.             hit_flag = true;
  325.         }
  326.     }
  327.     else if (current_player_number == 2) {
  328.         if (player_positions[current_player_number] == player_positions[current_player_number - 2]) {
  329.             cout << "Hit player a" << endl;
  330.             player_positions[current_player_number] = original_position;
  331.             hit_flag = true;
  332.         }
  333.         else if (player_positions[current_player_number] == player_positions[current_player_number - 1]) {
  334.             cout << "Hit player b" << endl;
  335.             player_positions[current_player_number] = original_position;
  336.             hit_flag = true;
  337.         }
  338.         else if (player_positions[current_player_number] == player_positions[current_player_number + 1]) {
  339.             cout << "Hit player d" << endl;
  340.             player_positions[current_player_number] = original_position;
  341.             hit_flag = true;
  342.         }
  343.     }
  344.     else if (current_player_number == 3) {
  345.         if (player_positions[current_player_number] == player_positions[current_player_number - 3]) {
  346.             cout << "Hit player a" << endl;
  347.             player_positions[current_player_number] = original_position;
  348.             hit_flag = true;
  349.         }
  350.         else if (player_positions[current_player_number] == player_positions[current_player_number - 2]) {
  351.             cout << "Hit player b" << endl;
  352.             player_positions[current_player_number] = original_position;
  353.             hit_flag = true;
  354.         }
  355.         else if (player_positions[current_player_number] == player_positions[current_player_number - 1]) {
  356.             cout << "Hit player c" << endl;
  357.             player_positions[current_player_number] = original_position;
  358.             hit_flag = true;
  359.         }
  360.     }
  361. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement