Advertisement
TawratNibir

Tic_Tac_Toe

Nov 23rd, 2024
211
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 22.55 KB | None | 0 0
  1. /*
  2. The following code is instructed to build a game.
  3. The game is commonly known "Tic Tac Toe"
  4. This code has some charecteristics:
  5. 1. The game consists of two mode: Single player and multiplayer.
  6. 2. Single player is played against a computer, the computer will generate random moves from 1 to 9, it will not make the best move.
  7. 3. User input maybe invalid, if any character or string or anything except an integer is given input as a move,
  8. it will automatically show invalid move on the screen.
  9. 4. Input from 1 to 9 will be a valid move on the grid shown on the screen.
  10. 5. Note that if any integer outside this range is given input, it will take the first digit
  11. of that integer as an input and make the move.
  12. 6. Multiplayer consists of simultaneous move from player 1 and player 2.
  13. 7. If any player put 'q' or 'Q' as an input, it will be treated as a resign,
  14. the program will be terminated and the other player will be declared the winner.
  15. 8. If a player can make 3 consecutive block with same fixed input, he will be declared winner.
  16. */
  17.  
  18. #include <stdio.h>
  19. #include <stdlib.h>
  20. #include <time.h>
  21.  
  22. int main()
  23. {
  24.     while (1)
  25.     {
  26.         char cell1, cell2, cell3, cell4, cell5, cell6, cell7, cell8, cell9;
  27.         char contiunuity;
  28.         int move, winner, move_validity, player, bot_move;
  29.         char move_p1, move_p2;
  30.         move = 9;
  31.         winner = 0;
  32.         move_validity = 0;
  33.  
  34.         printf("How do you want to play?\nSingle player: press 1\nMultiplayer: press 2\n");
  35.         scanf("%d", &player);
  36.  
  37.         cell1 = '0' + 1;
  38.         cell2 = '0' + 2;
  39.         cell3 = '0' + 3;
  40.         cell4 = '0' + 4;
  41.         cell5 = '0' + 5;
  42.         cell6 = '0' + 6;
  43.         cell7 = '0' + 7;
  44.         cell8 = '0' + 8;
  45.         cell9 = '0' + 9;
  46.  
  47.         printf("%c|%c|%c\n-----\n%c|%c|%c\n-----\n%c|%c|%c\n", cell1, cell2, cell3, cell4, cell5, cell6, cell7, cell8, cell9);
  48.         for (int i = 1; i <= 9; i++)
  49.         {
  50.             move = i;
  51.             if (move % 2 != 0)
  52.             {
  53.                 move_validity = 0;
  54.                 while (!move_validity)
  55.                 {
  56.                     printf("Which block do you want to make your move, player1?(o)\n\n");
  57.                     scanf(" %c", &move_p1);
  58.                     if (move_p1 == 'q' || move_p1 == 'Q')
  59.                     {
  60.                         if (player == 2)
  61.                         {
  62.                             printf("Game terminated!\nPlayer 2 is announced winner.");
  63.                             return 0;
  64.                         }
  65.                         else
  66.                         {
  67.                             printf("Game terminated!\nBot is announced winner.");
  68.                             return 0;
  69.                         }
  70.                     }
  71.                     if (move_p1 < '1' || move_p1 > '9')
  72.                     {
  73.                         move_validity = 0;
  74.                         printf("Invalid move.\n");
  75.                     }
  76.                     else
  77.                     {
  78.                         if (move_p1 == '1')
  79.                         {
  80.                             if (cell1 != 'o' && cell1 != 'x')
  81.                             {
  82.                                 cell1 = 'o';
  83.                                 move_validity = 1;
  84.                             }
  85.                             else
  86.                             {
  87.                                 move_validity = 0;
  88.                                 printf("Invalid move.\n");
  89.                             }
  90.                         }
  91.                         if (move_p1 == '2')
  92.                         {
  93.                             if (cell2 != 'o' && cell2 != 'x')
  94.                             {
  95.                                 cell2 = 'o';
  96.                                 move_validity = 1;
  97.                             }
  98.                             else
  99.                             {
  100.                                 move_validity = 0;
  101.                                 printf("Invalid move.\n");
  102.                             }
  103.                         }
  104.                         if (move_p1 == '3')
  105.                         {
  106.                             if (cell3 != 'o' && cell3 != 'x')
  107.                             {
  108.                                 cell3 = 'o';
  109.                                 move_validity = 1;
  110.                             }
  111.                             else
  112.                             {
  113.                                 move_validity = 0;
  114.                                 printf("Invalid move.\n");
  115.                             }
  116.                         }
  117.                         if (move_p1 == '4')
  118.                         {
  119.                             if (cell4 != 'o' && cell4 != 'x')
  120.                             {
  121.                                 cell4 = 'o';
  122.                                 move_validity = 1;
  123.                             }
  124.                             else
  125.                             {
  126.                                 move_validity = 0;
  127.                                 printf("Invalid move.\n");
  128.                             }
  129.                         }
  130.                         if (move_p1 == '5')
  131.                         {
  132.                             if (cell5 != 'o' && cell5 != 'x')
  133.                             {
  134.                                 cell5 = 'o';
  135.                                 move_validity = 1;
  136.                             }
  137.                             else
  138.                             {
  139.                                 move_validity = 0;
  140.                                 printf("Invalid move.\n");
  141.                             }
  142.                         }
  143.                         if (move_p1 == '6')
  144.                         {
  145.                             if (cell6 != 'o' && cell6 != 'x')
  146.                             {
  147.                                 cell6 = 'o';
  148.                                 move_validity = 1;
  149.                             }
  150.                             else
  151.                             {
  152.                                 move_validity = 0;
  153.                                 printf("Invalid move.\n");
  154.                             }
  155.                         }
  156.                         if (move_p1 == '7')
  157.                         {
  158.                             if (cell7 != 'o' && cell7 != 'x')
  159.                             {
  160.                                 cell7 = 'o';
  161.                                 move_validity = 1;
  162.                             }
  163.                             else
  164.                             {
  165.                                 move_validity = 0;
  166.                                 printf("Invalid move.\n");
  167.                             }
  168.                         }
  169.                         if (move_p1 == '8')
  170.                         {
  171.                             if (cell8 != 'o' && cell8 != 'x')
  172.                             {
  173.                                 cell8 = 'o';
  174.                                 move_validity = 1;
  175.                             }
  176.                             else
  177.                             {
  178.                                 move_validity = 0;
  179.                                 printf("Invalid move.\n");
  180.                             }
  181.                         }
  182.                         if (move_p1 == '9')
  183.                         {
  184.                             if (cell9 != 'o' && cell9 != 'x')
  185.                             {
  186.                                 cell9 = 'o';
  187.                                 move_validity = 1;
  188.                             }
  189.                             else
  190.                             {
  191.                                 move_validity = 0;
  192.                                 printf("Invalid move.\n");
  193.                             }
  194.                         }
  195.                     }
  196.                 }
  197.             }
  198.             else if (player == 1)
  199.             {
  200.                 move_validity = 0;
  201.                 srand(time(NULL));
  202.                 while (!move_validity)
  203.                 {
  204.                     // printf("Which block do you want to make your move, player2?(x)\n");
  205.                     // scanf("%d", &move_p2);
  206.                     bot_move = rand();
  207.                     int move_bot = bot_move % 10;
  208.                     if (move_bot < 1 && move_bot > 9)
  209.                     {
  210.                         move_validity = 0;
  211.                         // printf("Invalid move.\n");
  212.                     }
  213.                     else
  214.                     {
  215.                         if (move_bot == 1)
  216.                         {
  217.                             if (cell1 != 'o' && cell1 != 'x')
  218.                             {
  219.                                 cell1 = 'x';
  220.                                 move_validity = 1;
  221.                             }
  222.                             else
  223.                             {
  224.                                 move_validity = 0;
  225.                                 // printf("Invalid move.\n");
  226.                             }
  227.                         }
  228.                         if (move_bot == 2)
  229.                         {
  230.                             if (cell2 != 'o' && cell2 != 'x')
  231.                             {
  232.                                 cell2 = 'x';
  233.                                 move_validity = 1;
  234.                             }
  235.                             else
  236.                             {
  237.                                 move_validity = 0;
  238.                                 // printf("Invalid move.\n");
  239.                             }
  240.                         }
  241.                         if (move_bot == 3)
  242.                         {
  243.                             if (cell3 != 'o' && cell3 != 'x')
  244.                             {
  245.                                 cell3 = 'x';
  246.                                 move_validity = 1;
  247.                                 // printf("Invalid move.\n");
  248.                             }
  249.                             else
  250.                             {
  251.                                 move_validity = 0;
  252.                                 // printf("Invalid move.\n");
  253.                             }
  254.                         }
  255.                         if (move_bot == 4)
  256.                         {
  257.                             if (cell4 != 'o' && cell4 != 'x')
  258.                             {
  259.                                 cell4 = 'x';
  260.                                 move_validity = 1;
  261.                             }
  262.                             else
  263.                             {
  264.                                 move_validity = 0;
  265.                                 // printf("Invalid move.\n");
  266.                             }
  267.                         }
  268.                         if (move_bot == 5)
  269.                         {
  270.                             if (cell5 != 'o' && cell5 != 'x')
  271.                             {
  272.                                 cell5 = 'x';
  273.                                 move_validity = 1;
  274.                             }
  275.                             else
  276.                             {
  277.                                 move_validity = 0;
  278.                                 // printf("Invalid move.\n");
  279.                             }
  280.                         }
  281.                         if (move_bot == 6)
  282.                         {
  283.                             if (cell6 != 'o' && cell6 != 'x')
  284.                             {
  285.                                 cell6 = 'x';
  286.                                 move_validity = 1;
  287.                             }
  288.                             else
  289.                             {
  290.                                 move_validity = 0;
  291.                                 // printf("Invalid move.\n");
  292.                             }
  293.                         }
  294.                         if (move_bot == 7)
  295.                         {
  296.                             if (cell7 != 'o' && cell7 != 'x')
  297.                             {
  298.                                 cell7 = 'x';
  299.                                 move_validity = 1;
  300.                             }
  301.                             else
  302.                             {
  303.                                 move_validity = 0;
  304.                                 // printf("Invalid move.\n");
  305.                             }
  306.                         }
  307.                         if (move_bot == 8)
  308.                         {
  309.                             if (cell8 != 'o' && cell8 != 'x')
  310.                             {
  311.                                 cell8 = 'x';
  312.                                 move_validity = 1;
  313.                             }
  314.                             else
  315.                             {
  316.                                 move_validity = 0;
  317.                                 // printf("Invalid move.\n");
  318.                             }
  319.                         }
  320.                         if (move_bot == 9)
  321.                         {
  322.                             if (cell9 != 'o' && cell9 != 'x')
  323.                             {
  324.                                 cell9 = 'x';
  325.                                 move_validity = 1;
  326.                             }
  327.                             else
  328.                             {
  329.                                 move_validity = 0;
  330.                                 // printf("Invalid move.\n");
  331.                             }
  332.                         }
  333.                     }
  334.                 }
  335.             }
  336.             else
  337.             {
  338.                 move_validity = 0;
  339.                 while (!move_validity)
  340.                 {
  341.                     printf("Which block do you want to make your move, player2?(x)\n\n");
  342.                     scanf(" %c", &move_p2);
  343.                     if (move_p2 == 'q' || move_p2 == 'Q')
  344.                     {
  345.                         printf("Game terminated!\nPlayer 1 is announced winner.");
  346.                         return 0;
  347.                     }
  348.                     if (move_p2 < '1' || move_p2 > '9')
  349.                     {
  350.                         move_validity = 0;
  351.                         printf("Invalid move.\n");
  352.                     }
  353.                     else
  354.                     {
  355.                         if (move_p2 == '1')
  356.                         {
  357.                             if (cell1 != 'o' && cell1 != 'x')
  358.                             {
  359.                                 cell1 = 'x';
  360.                                 move_validity = 1;
  361.                             }
  362.                             else
  363.                             {
  364.                                 move_validity = 0;
  365.                                 printf("Invalid move.\n");
  366.                             }
  367.                         }
  368.                         if (move_p2 == '2')
  369.                         {
  370.                             if (cell2 != 'o' && cell2 != 'x')
  371.                             {
  372.                                 cell2 = 'x';
  373.                                 move_validity = 1;
  374.                             }
  375.                             else
  376.                             {
  377.                                 move_validity = 0;
  378.                                 printf("Invalid move.\n");
  379.                             }
  380.                         }
  381.                         if (move_p2 == '3')
  382.                         {
  383.                             if (cell3 != 'o' && cell3 != 'x')
  384.                             {
  385.                                 cell3 = 'x';
  386.                                 move_validity = 1;
  387.                                 printf("Invalid move.\n");
  388.                             }
  389.                             else
  390.                             {
  391.                                 move_validity = 0;
  392.                                 printf("Invalid move.\n");
  393.                             }
  394.                         }
  395.                         if (move_p2 == '4')
  396.                         {
  397.                             if (cell4 != 'o' && cell4 != 'x')
  398.                             {
  399.                                 cell4 = 'x';
  400.                                 move_validity = 1;
  401.                             }
  402.                             else
  403.                             {
  404.                                 move_validity = 0;
  405.                                 printf("Invalid move.\n");
  406.                             }
  407.                         }
  408.                         if (move_p2 == '5')
  409.                         {
  410.                             if (cell5 != 'o' && cell5 != 'x')
  411.                             {
  412.                                 cell5 = 'x';
  413.                                 move_validity = 1;
  414.                             }
  415.                             else
  416.                             {
  417.                                 move_validity = 0;
  418.                                 printf("Invalid move.\n");
  419.                             }
  420.                         }
  421.                         if (move_p2 == '6')
  422.                         {
  423.                             if (cell6 != 'o' && cell6 != 'x')
  424.                             {
  425.                                 cell6 = 'x';
  426.                                 move_validity = 1;
  427.                             }
  428.                             else
  429.                             {
  430.                                 move_validity = 0;
  431.                                 printf("Invalid move.\n");
  432.                             }
  433.                         }
  434.                         if (move_p2 == '7')
  435.                         {
  436.                             if (cell7 != 'o' && cell7 != 'x')
  437.                             {
  438.                                 cell7 = 'x';
  439.                                 move_validity = 1;
  440.                             }
  441.                             else
  442.                             {
  443.                                 move_validity = 0;
  444.                                 printf("Invalid move.\n");
  445.                             }
  446.                         }
  447.                         if (move_p2 == '8')
  448.                         {
  449.                             if (cell8 != 'o' && cell8 != 'x')
  450.                             {
  451.                                 cell8 = 'x';
  452.                                 move_validity = 1;
  453.                             }
  454.                             else
  455.                             {
  456.                                 move_validity = 0;
  457.                                 printf("Invalid move.\n");
  458.                             }
  459.                         }
  460.                         if (move_p2 == '9')
  461.                         {
  462.                             if (cell9 != 'o' && cell9 != 'x')
  463.                             {
  464.                                 cell9 = 'x';
  465.                                 move_validity = 1;
  466.                             }
  467.                             else
  468.                             {
  469.                                 move_validity = 0;
  470.                                 printf("Invalid move.\n");
  471.                             }
  472.                         }
  473.                     }
  474.                 }
  475.             }
  476.             if (cell1 == cell2 && cell2 == cell3)
  477.             {
  478.                 if (cell1 == 'o')
  479.                 {
  480.                     winner = 1;
  481.                 }
  482.                 else
  483.                 {
  484.                     winner = 2;
  485.                 }
  486.                 break;
  487.             }
  488.             if (cell1 == cell4 && cell4 == cell7)
  489.             {
  490.                 if (cell1 == 'o')
  491.                 {
  492.                     winner = 1;
  493.                 }
  494.                 else
  495.                 {
  496.                     winner = 2;
  497.                 }
  498.                 break;
  499.             }
  500.             if (cell1 == cell5 && cell5 == cell9)
  501.             {
  502.                 if (cell1 == 'o')
  503.                 {
  504.                     winner = 1;
  505.                 }
  506.                 else
  507.                 {
  508.                     winner = 2;
  509.                 }
  510.                 break;
  511.             }
  512.             if (cell4 == cell5 && cell5 == cell6)
  513.             {
  514.                 if (cell4 == 'o')
  515.                 {
  516.                     winner = 1;
  517.                 }
  518.                 else
  519.                 {
  520.                     winner = 2;
  521.                 }
  522.                 break;
  523.             }
  524.             if (cell7 == cell8 && cell8 == cell9)
  525.             {
  526.                 if (cell7 == 'o')
  527.                 {
  528.                     winner = 1;
  529.                 }
  530.                 else
  531.                 {
  532.                     winner = 2;
  533.                 }
  534.                 break;
  535.             }
  536.             if (cell7 == cell5 && cell5 == cell3)
  537.             {
  538.                 if (cell7 == 'o')
  539.                 {
  540.                     winner = 1;
  541.                 }
  542.                 else
  543.                 {
  544.                     winner = 2;
  545.                 }
  546.                 break;
  547.             }
  548.             if (cell2 == cell5 && cell5 == cell8)
  549.             {
  550.                 if (cell2 == 'o')
  551.                 {
  552.                     winner = 1;
  553.                 }
  554.                 else
  555.                 {
  556.                     winner = 2;
  557.                 }
  558.                 break;
  559.             }
  560.             if (cell3 == cell6 && cell6 == cell9)
  561.             {
  562.                 if (cell3 == 'o')
  563.                 {
  564.                     winner = 1;
  565.                 }
  566.                 else
  567.                 {
  568.                     winner = 2;
  569.                 }
  570.                 break;
  571.             }
  572.             if (player == 1)
  573.             {
  574.                 printf("Bot has made it's move. :V\n");
  575.             }
  576.             printf("%c|%c|%c\n-----\n%c|%c|%c\n-----\n%c|%c|%c\n\n", cell1, cell2, cell3, cell4, cell5, cell6, cell7, cell8, cell9);
  577.         }
  578.         if (winner == 0)
  579.         {
  580.             printf("Match is drawn!\n");
  581.         }
  582.         else if (winner == 1)
  583.         {
  584.             printf("%c|%c|%c\n-----\n%c|%c|%c\n-----\n%c|%c|%c\n\n", cell1, cell2, cell3, cell4, cell5, cell6, cell7, cell8, cell9);
  585.             if (player == 1)
  586.             {
  587.                 printf("Congratulations :D\nYour are the winner. You defeated your own bot.");
  588.             }
  589.             else
  590.             {
  591.                 printf("Congratulations! :D\nPlayer 1 is the winner.");
  592.             }
  593.         }
  594.         else if (winner == 2)
  595.         {
  596.             printf("%c|%c|%c\n-----\n%c|%c|%c\n-----\n%c|%c|%c\n\n", cell1, cell2, cell3, cell4, cell5, cell6, cell7, cell8, cell9);
  597.             if (player == 1)
  598.             {
  599.                 printf("Sorry you lost! :(\nBot is the winner.");
  600.             }
  601.             else
  602.             {
  603.                 printf("Congratulations! :D\nPlayer 2 is the winner.");
  604.             }
  605.         }
  606.         printf("\nWill you want to play again?: Y or y for Yes and any other key for No: \n");
  607.  
  608.         scanf(" %c", &contiunuity);
  609.         if (contiunuity == 'Y' || contiunuity == 'y')
  610.         {
  611.             continue;
  612.         }
  613.         else
  614.         {
  615.             printf("Thanks for playing. :D\n");
  616.             break;
  617.         }
  618.     }
  619. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement