Tic-Tac-Toe Game - Need some information or help

Please support our C++ advertiser: Programming Forums - DaniWeb Sister Site
Reply

•
•
Join Date: Jan 2007
Posts: 171
Reputation: Lazaro Claiborn is an unknown quantity at this point 
Solved Threads: 13
Lazaro Claiborn's Avatar
Lazaro Claiborn Lazaro Claiborn is offline Offline
Junior Poster

Tic-Tac-Toe Game - Need some information or help

 
0
  #1
Feb 15th, 2007
Hello,

I've recently, inadvertently, found incentive to write my own Tic-Tac-Toe game. I've been working on it for more-or-less 15 minutes and would like some help or a point in the right direction. It is almost finished but there is a function, namely the "_scan4Winner" function, that I must write an algorithm or come up with a formula to check for a winning condition.

C++ Syntax (Toggle Plain Text) 
  1. #include <iostream>
  2. #include <stdlib.h>
  3. #include <stdio.h>
  4. #include <time.h>
  5.  
  6. using namespace std;
  7.  
  8. #define NWIN_CON 0
  9. #define PONE_WIN 1
  10. #define PTWO_WIN 2
  11. #define GRST 2
  12.  
  13. const char playerOne = 'X';
  14. const char playerTwo = 'O';
  15.  
  16. int _writeGrid( int y, int x, int flag );
  17. int _scan4Winner(char (*grid)[3]);
  18. int _playerWin(int winner);
  19.  
  20. int main()
  21. {
  22.     char setLocation;
  23.     /* char hexc = 0x41; */
  24.     int randomee, turn, ret;
  25.     int px = 0, py = 0;
  26.  
  27.     srand(time(NULL)); // Seed for random
  28.  
  29.     // This will put a random number between 1 and 10 which will
  30.     // determine what player initially goes first
  31.     randomee = rand() % 10 + 1;
  32.  
  33.     // Which player goes first
  34.     turn = (randomee >= 5) ? 1 : 0;
  35.  
  36.     // Indicate which user goes first
  37.     cout << "Player " << turn << "is first" << endl;
  38.  
  39.      // This will print a fresh new grid
  40.     _writeGrid(NULL, NULL, GRST);
  41.  
  42.     // Start the actual game
  43.     while (1)
  44.     {
  45.         cout << "Player " << turn << " set: ";
  46.         cin  >> setLocation;
  47.  
  48.         switch (setLocation)
  49.         {
  50.             case 0x41 :
  51.                 px = 0;
  52.                 py = 0;
  53.                 break;
  54.             case 0x42 :
  55.                 px = 1;
  56.                 py = 0;
  57.                 break;
  58.             case 0x43 :
  59.                 px = 2;
  60.                 py = 0;
  61.                 break;
  62.             case 0x44 :
  63.                 px = 0;
  64.                 py = 1;
  65.                 break;
  66.             case 0x45 :
  67.                 px = 1;
  68.                 py = 1;
  69.                 break;
  70.             case 0x46 :
  71.                 px = 2;
  72.                 py = 1;
  73.                 break;
  74.             case 0x47 :
  75.                 px = 0;
  76.                 py = 2;
  77.                 break;
  78.             case 0x48 :
  79.                 px = 1;
  80.                 py = 2;
  81.                 break;
  82.             case 0x49 :
  83.                 px = 2;
  84.                 py = 2;
  85.                 break;
  86.         }
  87.  
  88.        /*************************************
  89.         while (hexc != 0x49)
  90.         {
  91.             if (setLocation == hexc)
  92.             {
  93.                ret = _writeGrid(py, px, turn);
  94.                hexc = 0x41;
  95.                px = 0;
  96.                py = 0;
  97.                break;
  98.             }
  99.             hexc++;
  100.             if (px < 2)
  101.                 px++;
  102.             else
  103.             {
  104.                 px = 0;
  105.                 py++;
  106.             }
  107.         }
  108.        ****************************************/
  109.  
  110.         // Once the coords are determined pass them and which player is 
  111.         // going, return and check if that player won.
  112.         ret = _writeGrid(px, py, turn);
  113.  
  114.         if (ret == PONE_WIN)
  115.         {
  116.             turn = 0;
  117.             _writeGrid(NULL, NULL, GRST);
  118.         }
  119.         else if (ret == PTWO_WIN)
  120.         {
  121.             turn = 1;
  122.             _writeGrid(NULL, NULL, GRST);
  123.         }
  124.         else
  125.             turn = (turn) ? 0 : 1; // If no one won yet switch players
  126.     }
  127.  
  128.  return 0;
  129. }
  130.  
  131. // This function writes a 3 x 3 tic-tac-toe grid and adds an X or a O 
  132. // depending on the current user, and also takes a grid corrdinates 
  133. // that'll determine the position or the X or O before it prints the grid
  134. int _writeGrid(int y, int x, int flag)
  135. {
  136.     static char gridMap[3][3]; // Make static so grid is remembered
  137.     int i, j, winner;
  138.     char hexc = 0x41;
  139.  
  140.     // If the flag is a reset flag, reset the whole grid
  141.     if (flag == GRST)
  142.     {
  143.         for (i=0;i<3;i++)
  144.         {
  145.             for (j=0;j<3;j++)
  146.             {
  147.                 gridMap[i][j] = hexc;
  148.                 hexc++;
  149.                 cout << "|  " << gridMap[i][j];
  150.             }
  151.             cout << endl << endl;
  152.         }
  153.         return GRST;
  154.     }
  155.     else
  156.     {
  157.         // Condition flag and place either an X(playerOne) or O 
  158.         // (playerTwo) into the coords passed as parameters
  159.         gridMap[x][y] = (flag) ? playerOne : playerTwo;
  160.         system("cls");
  161.  
  162.         // This section will actually write the grid using the values
  163.         // stored in gridMap
  164.         for (i=0;i<3;i++)
  165.         {
  166.             for (j=0;j<3;j++)
  167.             {
  168.                 cout << "|  " << gridMap[i][j];
  169.             }
  170.             cout << endl << endl;
  171.         }
  172.  
  173.         // The next step is to check for a winner so we pass gridMap 
  174.         // containing the actual grid status winner = _scan4Winner   
  175.         // (gridMap) If a winning condition is encountered notify the 
  176.         // player who wins, add one point to his current score and reset   
  177.         // the grid.
  178.         if (winner)
  179.             return _playerWin((flag) ? PONE_WIN : PTWO_WIN);
  180.  
  181.         return NWIN_CON;
  182.     }
  183. }
  184.  
  185. // This function will have a formula or algorition that'll check for
  186. // winning conditions.
  187. int _scan4Winner(char (*grid)[3])
  188. {
  189.     return 0;
  190. }
  191.  
  192. // This function simply prints whose the winner of a tic-tac-toe game 
  193. // and increments a counter variable for the corresponding user
  194. int _playerWin(int winner)
  195. {
  196.     static int pcount1;
  197.     static int pcount2;
  198.     if (winner == PONE_WIN)
  199.     {
  200.         pcount1++;
  201.         cout << "Player one wins -  score is" << pcount1 << endl;
  202.         return PONE_WIN;
  203.     }
  204.     else
  205.     {
  206.         pcount2++;
  207.         cout << "Player two wins -  score is" << pcount2 << endl;
  208.         return PTWO_WIN;
  209.     }
  210. }

Thanks in advanced, LamaBot
Last edited by Lazaro Claiborn; Feb 15th, 2007 at 5:29 pm. Reason: Comment not perfect
Reply With Quote Quick reply to this message  
•
•
Join Date: May 2006
Posts: 3,131
Reputation: WaltP has much to be proud of WaltP has much to be proud of WaltP has much to be proud of WaltP has much to be proud of WaltP has much to be proud of WaltP has much to be proud of WaltP has much to be proud of WaltP has much to be proud of WaltP has much to be proud of 
Solved Threads: 283
Moderator
WaltP's Avatar
WaltP WaltP is offline Offline
Posting Sensei

Re: Tic-Tac-Toe Game - Need some information or help

 
0
  #2
Feb 16th, 2007
Easiest is to pass in the position of the last move then check each direction from that location for 3 in a row.
The 3 Laws of the Procrastination Society:
1) Never do today that which can be put off until tomorrow
2) Tomorrow never comes
Reply With Quote Quick reply to this message  
•
•
Join Date: Jan 2007
Posts: 171
Reputation: Lazaro Claiborn is an unknown quantity at this point 
Solved Threads: 13
Lazaro Claiborn's Avatar
Lazaro Claiborn Lazaro Claiborn is offline Offline
Junior Poster

Re: Tic-Tac-Toe Game - Need some information or help

 
0
  #3
Feb 16th, 2007
•
•
•
•
Originally Posted by WaltP View Post
Easiest is to pass in the position of the last move then check each direction from that location for 3 in a row.
Awesome Waltp,

I didn't do exactly what you'd said but you gave me an idea. I figured that'd I check on every move and just pass the whole array so that even if the player were to move in the middle of a given check it'll still work without writing extra code to detect where to scan relative to the most current position. Wicked cool! Thanks again Waltp. Also, since you're a Moderator, perhaps you can point me in the right direction where I can upload some tutorials or something? If not, its cool, I'll find it sooner or later. Last, in the previously posted code, I accidently rendered a statement as a comment, namely the "winner = _scan4Winner(gridMap)"; I was trying to make it look pretty and I messed it up I guess. :o Here is the code for the _scan4Winner function and all affiliated functions:

C++ Syntax (Toggle Plain Text) 
  1. // This function writes a 3 x 3 tic-tac-toe grid and adds an X or a O 
  2. // depending on the current user, and also takes a grid corrdinates 
  3. // that'll determine the position or the X or O before it prints the grid
  4. int _writeGrid(int y, int x, int flag)
  5. {
  6.     static char gridMap[3][3]; // Make static so grid is remembered
  7.     int i, j, winner;
  8.     char hexc = 0x41;
  9.  
  10.     // If the flag is a reset flag, reset the whole grid
  11.     if (flag == GRST)
  12.     {
  13.         for (i=0;i<3;i++)
  14.         {
  15.             for (j=0;j<3;j++)
  16.             {
  17.                 gridMap[i][j] = hexc;
  18.                 hexc++;
  19.                 cout << "   " << gridMap[i][j];
  20.             }
  21.             cout << endl << endl;
  22.         }
  23.         return SUCCESS;
  24.     }
  25.     else
  26.     {
  27.         system("cls");
  28.  
  29.         // Condition flag and place either an X(playerOne) or O
  30.         //(playerTwo) into the coords passed as parameters
  31.        if (gridMap[x][y] != 'X' && gridMap[x][y] != 'O')
  32.             gridMap[x][y] = (flag) ? playerOne : playerTwo;
  33.         else
  34.             cout << "That position is already occupied" << endl << endl;
  35.        if (_checkFull(gridMap))
  36.             return GRST;
  37.  
  38.  
  39.         // This section will actually write the grid using the values
  40.         // stored in gridMap
  41.         for (i=0;i<3;i++)
  42.         {
  43.             for (j=0;j<3;j++)
  44.                 cout << "   " << gridMap[i][j];
  45.             cout << endl << endl;
  46.         }
  47.  
  48.         // The next step is to check for a winner so we pass gridMap 
  49.         // which contains the actually grid status. Note, this is the 
  50.         // statement that got accidently included with the comments 
  51.         // of the first posted code
  52.          winner = _scan4Winner(gridMap); 
  53.  
  54.          // If a winning condition is encountered notify the player who 
  55.          //wins, add one point to his current score and reset the grid
  56.         if (winner)
  57.             return _playerWin(winner);
  58.  
  59.         return NWIN_CON;
  60.     }
  61. }
  62.  
  63. // This function will have a formula or algorition that'll check for
  64. // winning conditions.
  65. int _scan4Winner(char (*grid)[3])
  66. {
  67.     if (_checkDiagnol(grid, 'X') || _checkAcross(grid, 'X') || _checkDown(grid, 'X'))
  68.         return PONE_WIN;
  69.     else if (_checkDiagnol(grid, 'O') || _checkAcross(grid, 'O') || _checkDown(grid, 'O'))
  70.         return PTWO_WIN;
  71.  
  72.     return NWIN_CON;
  73. }
  74.  
  75. // This function simply prints whose the winner of a tic-tac-toe game 
  76. // and increments a counter variable for the corresponding user
  77. int _playerWin(int winner)
  78. {
  79.     static int pcount1;
  80.     static int pcount2;
  81.  
  82.     if (winner == PONE_WIN)
  83.     {
  84.         pcount1++;
  85.         cout << "Player one wins - win score is " << pcount1 << endl;
  86.         return PONE_WIN;
  87.     }
  88.     else
  89.     {
  90.         pcount2++;
  91.         cout << "Player two wins - win score is " << pcount2 << endl;
  92.         return PTWO_WIN;
  93.     }
  94. }
  95.  
  96. // Check both diagnol directions
  97. bool _checkDiagnol(char (*grid)[3], char player)
  98. {
  99.     int i, j, counter1 , counter2;
  100.     j = counter1 = counter2 = 0;
  101.  
  102.     for (i=0;i<3;i++)
  103.     {
  104.         if (grid[j][i] == player)
  105.             counter1++;
  106.         j++;
  107.     }
  108.     j=0;
  109.     for (i=2;i>=0;i--)
  110.     {
  111.         if (grid[j][i] == player)
  112.             counter2++;
  113.         j++;
  114.     }
  115.     return (counter1 == 3 || counter2 == 3) ? true : false;
  116. }
  117.  
  118. // Across down the Y axis
  119. bool _checkAcross(char (*grid)[3], char player)
  120. {
  121.     int i, j, counter;
  122.     counter = 0;
  123.  
  124.     for (i=0;i<3;i++)
  125.     {
  126.        for (j=0;j<3;j++)
  127.        {
  128.            if (grid[i][j] == player)
  129.                 counter++;
  130.        }
  131.        if (counter >= 3)
  132.             return true;
  133.        else
  134.             counter = 0;
  135.     }
  136.     return false;
  137. }
  138.  
  139. // Check down across the X axis
  140. bool _checkDown(char (*grid)[3], char player)
  141. {
  142.     int i, j, counter;
  143.     counter = j = 0;
  144.     for (i=0;i<3;i++)
  145.     {
  146.         for (j=0;j<3;j++)
  147.         {
  148.             if (grid[j][i] == player)
  149.                 counter++;
  150.         }
  151.         if (counter == 3)
  152.              return true;
  153.         else
  154.             counter = 0;
  155.     }
  156.     return false;
  157. }
  158.  
  159. // Check for a full grid
  160. static bool _checkFull(char (*grid)[3])
  161. {
  162.     int i, j;
  163.  
  164.     for (i=0;i<3;i++)
  165.     {
  166.         for (j=0;j<3;j++)
  167.         {
  168.             if (grid[i][j] != 'X' && grid[i][j] != 'O')
  169.                 return 0;
  170.         }
  171.     }
  172.     return 1;
  173. }

I'll probably need to modify the code, but it works fine for right now. Any suggestions will be much appreciated.

Thanks a lot, LamaBot
Reply With Quote Quick reply to this message  
•
•
Join Date: May 2006
Posts: 3,131
Reputation: WaltP has much to be proud of WaltP has much to be proud of WaltP has much to be proud of WaltP has much to be proud of WaltP has much to be proud of WaltP has much to be proud of WaltP has much to be proud of WaltP has much to be proud of WaltP has much to be proud of 
Solved Threads: 283
Moderator
WaltP's Avatar
WaltP WaltP is offline Offline
Posting Sensei

Re: Tic-Tac-Toe Game - Need some information or help

 
0
  #4
Feb 17th, 2007
With this solution you are checking 3 colums, 3 rows, and 2 diagonals. IOW 8 tests.
If you pass in the last move, you can check 1 row, 1 col, and 0, 1, or 2 diagonals. For this, a maximum of 4 tests. To check to see if a diagonal has to be tested,
C++ Syntax (Toggle Plain Text) 
  1. if both indexes are 1, both diagonals must be tested (center square)
  2. else
  3. if either index is 1 there are no diagonals (side square)
  4. else
  5. test one diagonal (corner square)
The 3 Laws of the Procrastination Society:
1) Never do today that which can be put off until tomorrow
2) Tomorrow never comes
Reply With Quote Quick reply to this message  
•
•
Join Date: Jan 2007
Posts: 171
Reputation: Lazaro Claiborn is an unknown quantity at this point 
Solved Threads: 13
Lazaro Claiborn's Avatar
Lazaro Claiborn Lazaro Claiborn is offline Offline
Junior Poster

Re: Tic-Tac-Toe Game - Need some information or help

 
0
  #5
Feb 18th, 2007
•
•
•
•
Originally Posted by WaltP View Post
With this solution you are checking 3 colums, 3 rows, and 2 diagonals. IOW 8 tests.
If you pass in the last move, you can check 1 row, 1 col, and 0, 1, or 2 diagonals. For this, a maximum of 4 tests. To check to see if a diagonal has to be tested,
C++ Syntax (Toggle Plain Text) 
  1. if both indexes are 1, both diagonals must be tested (center square)
  2. else
  3. if either index is 1 there are no diagonals (side square)
  4. else
  5. test one diagonal (corner square)
Hey Waltp,

Sorry I havn't replied sooner, but I've had work today
I understood what you suggestion, and it works. I kind of re-wrote the program, created classes for my nueral network (3 layer-forward model) and started to write some activations functions; as to see which one seems fit during training, and yes, I am going to incorporate an AI don't ask why:lol: Some of the programs original functionality doesn't work, in particular the "_endGame(void)" function will not end the game but simply allows you to view a winners score before resetting the grid. I'll change this laters as I develope my AI, which I might need some help, hopefully you, now-and-then???? Anyway, thanks for the suggestion; To think, I've got experienced with AI yet I can't deviate, figure and reckon that 8 tests would be better than 4!!!! Need to stop plumbing and start programming more again. Enough babbling, here is the code:

C++ Syntax (Toggle Plain Text) 
  1. #include <iostream>
  2. #include <stdlib.h>
  3. #include <stdio.h>
  4. #include <time.h>
  5.  
  6. using namespace std;
  7.  
  8. #define PONE_WIN 0
  9. #define PTWO_WIN 1
  10. #define GREG 1
  11. #define GRST 2
  12.  
  13. const char player[] = "XO";
  14. char grid[3][3];
  15. void _writeGrid(int flag);
  16. void _playerWin(int winner);
  17.  
  18. inline bool _checkDiagnolDecline(char player) {
  19.     return (grid[1][1]==player && grid[2][2]==player && grid[0][0]==player) ? true : false;
  20. }
  21. inline bool _checkDiagnolIncline(char player) {
  22.     return (grid[2][0]==player && grid[0][2]==player && grid[1][1]==player) ? true : false;
  23. }
  24. inline bool _checkDown(int x, char player) {
  25.         return (grid[0][x]==player && grid[1][x]==player && grid[2][x]==player) ? true : false;
  26. }
  27. inline bool _checkAcross(int y, char player) {
  28.         return (grid[y][0]==player && grid[y][1]==player && grid[y][2]==player) ? true : false;
  29. }
  30.  
  31. static inline int _endGame(void) {
  32.     char endGame;
  33.     cout << "Would you like to play another game? y / n ";
  34.     cin >> endGame;
  35.     if (endGame == 'y' || endGame == 'Y')
  36.         return 0;
  37.     return 1;
  38. }
  39.  
  40. static bool _checkFull(void);
  41.  
  42. int main() {
  43.     char setLocation, endGame;
  44.     char hexc = 0x41;
  45.     int randomee, turn, ret;
  46.     int px = 0, py = 0;
  47.  
  48.     srand(time(NULL)); // Seed for random
  49.     randomee = rand() % 10 + 1;
  50.     turn = (randomee >= 5) ? 1 : 0;
  51.     cout << "Player " << turn << " is first" << endl << endl;
  52.     _writeGrid(GRST);
  53.  
  54.     while (1) {
  55.         cout << "Player " << turn << " set: ";
  56.         cin  >> setLocation;
  57.         switch (setLocation) {
  58.             case 0x41 :
  59.                 px = 0;
  60.                 py = 0;
  61.                 break;
  62.             case 0x42 :
  63.                 px = 1;
  64.                 py = 0;
  65.                 break;
  66.             case 0x43 :
  67.                 px = 2;
  68.                 py = 0;
  69.                 break;
  70.             case 0x44 :
  71.                 px = 0;
  72.                 py = 1;
  73.                 break;
  74.             case 0x45 :
  75.                 px = 1;
  76.                 py = 1;
  77.                 break;
  78.             case 0x46 :
  79.                 px = 2;
  80.                 py = 1;
  81.                 break;
  82.             case 0x47 :
  83.                 px = 0;
  84.                 py = 2;
  85.                 break;
  86.             case 0x48 :
  87.                 px = 1;
  88.                 py = 2;
  89.                 break;
  90.             case 0x49 :
  91.                 px = 2;
  92.                 py = 2;
  93.                 break;
  94.         }
  95.         if (grid[py][px] == player[0] || grid[py][px] == player[1])
  96.             cout << "Position is occupied" << endl;
  97.         else {
  98.             grid[py][px] = player[turn];
  99.  
  100.             if (_checkFull()) {
  101.             } else {
  102.                 if (py==1 && px==1) {
  103.                     if (_checkDiagnolIncline(player[turn]) || _checkDiagnolDecline(player[turn]))
  104.                         _playerWin(turn);
  105.                 } else if (!py && !px || py==2 && px==2) {
  106.                     if (_checkDiagnolDecline(player[turn]))
  107.                         _playerWin(turn);
  108.                 } else if (py==2 && px==0 || py==0 && px==2) {
  109.                     if (_checkDiagnolIncline(player[turn]))
  110.                         _playerWin(turn);
  111.                 }
  112.  
  113.                 if (_checkAcross(py, player[turn]))
  114.                     _playerWin(turn);
  115.                 if (_checkDown(px, player[turn]))
  116.                     _playerWin(turn);
  117.  
  118.                 _writeGrid(GREG);
  119.                 turn = (turn) ? 0 : 1;
  120.             }
  121.         }
  122.     }
  123.     return 0;
  124. }
  125.  
  126. void _writeGrid(int flag) {
  127.     int i, j;
  128.     char hexc = 0x41;
  129.  
  130.     if (flag == GRST) {
  131.         for (i=0;i<3;i++) {
  132.             for (j=0;j<3;j++) {
  133.                 grid[i][j] = hexc;
  134.                 hexc++;
  135.                 cout << "   " << grid[i][j];
  136.             }
  137.             cout << endl << endl;
  138.         }
  139.     } else {
  140.         system("cls");
  141.             for (i=0;i<3;i++) {
  142.             for (j=0;j<3;j++)
  143.                 cout << "   " << grid[i][j];
  144.             cout << endl << endl;
  145.         }
  146.     }
  147. }

Does that look right? I'm still open for suggestions and I've got some ideas of my own I'll post later on, but I'm freaking tired.

Thanks in advance, LamaBot
Last edited by Lazaro Claiborn; Feb 18th, 2007 at 1:48 am. Reason: formatting
Reply With Quote Quick reply to this message  
•
•
Join Date: May 2006
Posts: 3,131
Reputation: WaltP has much to be proud of WaltP has much to be proud of WaltP has much to be proud of WaltP has much to be proud of WaltP has much to be proud of WaltP has much to be proud of WaltP has much to be proud of WaltP has much to be proud of WaltP has much to be proud of 
Solved Threads: 283
Moderator
WaltP's Avatar
WaltP WaltP is offline Offline
Posting Sensei

Re: Tic-Tac-Toe Game - Need some information or help

 
0
  #6
Feb 18th, 2007
•
•
•
•
Originally Posted by Lazaro Claiborn View Post
Sorry I havn't replied sooner, but I've had work today
No problem. It's not like I was waiting by the computer just for you :mrgreen:

•
•
•
•
Originally Posted by Lazaro Claiborn View Post
Anyway, thanks for the suggestion; To think, I've got experienced with AI yet I can't deviate, figure and reckon that 8 tests would be better than 4!!!!
It all comes with more time and more experience. I remember one program I wrote with multiple nested for loops (15 I think) -- took over 3 pages and a couple bad practices. Less than a year later I rewrote the entire program to less than 1 page. Knowledge can come at you fast...

•
•
•
•
Originally Posted by Lazaro Claiborn View Post
c Syntax (Toggle Plain Text) 
  1.  
  2.         cin  >> setLocation;
  3.         switch (setLocation) {
  4.             case 0x41 :
  5.                 px = 0;
  6.                 py = 0;
  7.                 break;
  8.             case 0x42 :
  9.                 px = 1;
  10.                 py = 0;
  11.                 break;
  12.             case 0x43 :
  13.                 px = 2;
  14.                 py = 0;
  15.                 break;
  16.             case 0x44 :
  17.                 px = 0;
  18.                 py = 1;
  19.                 break;
  20.             case 0x45 :
  21.                 ...
  22.                 py = 2;
  23.                 break;
  24.         }
This whole section can be reduced to 2 simple equations. Hint: Subract 41 from setLocation and look at division and modulus operators...

•
•
•
•
Originally Posted by Lazaro Claiborn View Post
Does that look right? I'm still open for suggestions and I've got some ideas of my own I'll post later on, but I'm freaking tired.
If it works, it's (probably) right. I didn't look at the whole thing, but the above jumped out at me big time...
The 3 Laws of the Procrastination Society:
1) Never do today that which can be put off until tomorrow
2) Tomorrow never comes
Reply With Quote Quick reply to this message  
•
•
Join Date: Jan 2007
Posts: 171
Reputation: Lazaro Claiborn is an unknown quantity at this point 
Solved Threads: 13
Lazaro Claiborn's Avatar
Lazaro Claiborn Lazaro Claiborn is offline Offline
Junior Poster

Re: Tic-Tac-Toe Game - Need some information or help

 
0
  #7
Feb 18th, 2007
•
•
•
•
Originally Posted by WaltP View Post
No problem. It's not like I was waiting by the computer just for you :mrgreen:
Ah you were'nt, darn, and all this time.... Lol - just playing :lol:

You'll have to forgive my spunky personality. I used the method(s) you suggested; the obviously one insinuated was:

C++ Syntax (Toggle Plain Text) 
  1. px = (setLocation - 0x41) % 3; // Duh...;)

In a non-defensive manner of speaking, because I wrote the original program relatively fast I didn't put to much time in code efficiency - meaning I usually write the steps of a program and modify the code later for efficiency. Although you helped me from having to really think about it and I appreciate your expertise.

Thanks, LamaBot
Last edited by Lazaro Claiborn; Feb 18th, 2007 at 3:36 pm.
Reply With Quote Quick reply to this message  
Reply

Quick Reply to Thread
This thread is more than three months old.
Perhaps start a new thread instead?
•
•
•
•
•
•
•
•
Message:
•
•
•
•



Similar Threads
Other Threads in the C++ Forum


Views: 3200 | Replies: 6
Thread Tools Search this Thread



Tag cloud for C++
6 api application array arrays assignment based beginner binary c++ c/c++ calculator char char* class classes code coding compile compiler console conversion convert count data database delete developer display dll dynamiccharacterarray email encryption error file format forms fstream function functions game generator givemetehcodez graph iamthwee ifstream image input int java lib list loop looping loops map math matrix memory multidimensional multiple newbie news number numbertoword output pointer problem program programming project python random read recursion recursive reference return rpg search sort sorting string strings struct template templates text tree url variable vector video visual visualstudio win32 windows winsock wordfrequency wxwidgets
About Us | Contact Us | Advertise | DaniWeb | Acceptable Use Policy | RSS Feed

©2003 - 2009 DaniWeb® LLC