Thread: tic tac toe(again xD)

Have a tic tac toe program which works fine expect the computer decides to cheat every once in a while.
If after making a move it can then win by making another move, for some reason it makes that move, and then if it can win again it will make a third move etc.
As there is only once statement actually changing the value of the board i thought it must be an issue with loops or something, but i just can't find it.
Also, while you're checking the code, can anyone suggest ways of making it more efficient/less clunky?

Thanks,

Code:

Code:

#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <time.h>
using namespace std;

//  Declare Variables
      int loopcountrow;
      int loopcountcol;
      int loopcount;
      int board[9];
      int aiboard[3][3];
      int movex;
      int move;
      int aimove;
      int win=0;
      int endc;
      int player=1;
      int playerc;
      int i;
      int itt;
      int moo;
      int numove=0;
      int ai;
      int randint;
     
      
//////////////////////////////////////////////
/////////////////                  //////////////
/////////////////   -=0 X=1 O=2    ////////////////
/////////////////                  /////////////////
/////////////////////////////////////////////////////
void drawboard()
{
     cout << endl;
         
     for (loopcountrow = 0; loopcountrow < 3; loopcountrow = loopcountrow + 1)
        {  
                                       
         for (loopcountcol = 0; loopcountcol < 3; loopcountcol = loopcountcol + 1)
             {
             loopcount = (loopcountrow*3)+loopcountcol;
             switch(board[loopcount])
             {
             case 0:
                  cout << "-";
                  break;
             case 1:
                  cout << "X";
                  break;
             case 2:
                  cout << "O";
                  break;
             default:
                  cout << "-";
              }
         
          }
      cout << endl;
         
       }
}
/////////////////////////////////////////////////////////////////////////
void aichoosemovetwo()
{
for (moo=2; moo>0; --moo)
{
    /// blockandwin rows  
    for (i=0;i<3; ++i)
    {
        if (aiboard[i][0]==moo && aiboard[i][1]==moo && aiboard[i][2]==0)
        {
            aimove=((((i+1)*3)-3)+2);
            return;                 
        }
            if (aiboard[i][0]==moo && aiboard[i][2]==moo && aiboard[i][1]==0)
        {
            aimove=((((i+1)*3)-3)+1);
            return;                 
        }
            if (aiboard[i][1]==moo && aiboard[i][2]==moo && aiboard[i][0]==0)
        {
            aimove=(((i+1)*3)-3);
            return;                 
        }
          
    ///blockandwin columns
        
        if (aiboard[0][i]==moo && aiboard[1][i]==moo && aiboard[2][i]==0)
        {
            aimove=6+i;
            return;                 
        }
            if (aiboard[0][i]==moo && aiboard[2][i]==moo && aiboard[1][i]==0)
        {
            aimove=3+i;
            return;                 
        }
            if (aiboard[1][i]==moo && aiboard[2][i]==moo && aiboard[0][i]==0)
        {
            aimove=0+i;
            return;                 
        }
    } 
    ///blockandwin! diagonals
//to be continued XD


}    
    
}


////////////////////////////////////////////////////////////////////////
int aichoosemove()
{

    randint = (rand()%9);
 if (board[randint]==0)
 {
     aimove=randint;
 }else{
     aichoosemove();
 }  
 
aiboard[0][0]=board[0];
aiboard[0][1]=board[1];
aiboard[0][2]=board[2];
aiboard[1][0]=board[3];
aiboard[1][1]=board[4];
aiboard[1][2]=board[5];
aiboard[2][0]=board[6];
aiboard[2][1]=board[7];
aiboard[2][2]=board[8];
     
aichoosemovetwo();
  
 board[aimove]=2;
 numove++;
 player=1;   
}

///////////////////////////////////////////////////////////////////////////

   void inputmove()
{
if(ai==2 && player==2){
    aichoosemove();     
}else{
     cout << endl;
     cout << "Player " << player << endl;
     cout << "Where would you like to move? >> ";
     cin >> movex;
     if (movex>9)
     {
         cout << "Invalid Move" << endl;
         inputmove();
     }
     move=movex-1;
     switch(board[move])
     {
     case 0:
          board[move]=player;
          if(player==1)
          {                   
               player=2; 
          }else{                 
               player=1; 
          }
          
          numove++;             
          break;
     case 1:
          cout << "Invalid Move" << endl;
          inputmove();
          break;
     case 2:
          cout << "Invalid Move" << endl;
          inputmove();
          break;
     }
}

   }
/////////////////////////////////////////////////////////////////////////
void checkwin() 
{

     for (i=1; i<3; i=++i)
     {
               if (board[0]==i && board[3]==i && board[6]==i)
               {
                  win=i;
               }
               if (board[0]==i && board[3]==i && board[6]==i)
               {
                 win=i;
               }
               if (board[1]==i && board[4]==i && board[7]==i)
               {
                  win=i;
               }
               if (board[2]==i && board[5]==i && board[8]==i)
               {
                  win=i;
               }
               if (board[0]==i && board[1]==i && board[2]==i)
               {
                  win=i;
               }
               if (board[3]==i && board[4]==i && board[5]==i)
               {
                  win=i;
               }
               if (board[6]==i && board[7]==i && board[8]==i)
               {
                  win=i;
               }    
               if (board[0]==i && board[4]==i && board[8]==i)
               {
                  win=i;
               }
               if (board[2]==i && board[4]==i && board[6]==i)
               {
                  win=i;
               }
     }
     if(numove==9)
     {
     win=3;
     }
 }

/////////////////////////////////////////////////////////////////////////
int aichoose()
{
   cout << "Player vs Player? (1)" << endl;
    cout << "Or" << endl;;
    cout << "Player vs Computer? (2)" << endl;
    cin >> ai; 
    if (ai==1 ^ ai==2){
             
    }else{
          cout << endl;
          cout << "Invalid Option";
          cout << endl;
          aichoose();
    }
}

/////////////////////////////////////////////////////////////////////////
     
int main()
{
     srand((unsigned)time(0));
    aichoose();
    do
    {
          drawboard();
          inputmove();
          checkwin();
   }while(win==0);
   
    drawboard();
     cout << endl;
     switch(win)
     {
       case 1:
           cout << "Player 1 Wins!";
           break;
       case 2:
            if (ai==1)
            {
                  cout << "Player 2 Wins!";
            }else{
                  cout << "Computer Wins!";  
            }
            break;
       case 3:
            cout << "Draw =(";
            break;
       default:
            cout << "QQ";
       }
       cout << endl;
       system("PAUSE");

return 0;
}

No, thats not the problem, it only takes unoccupied squares, but it takes multiple turns when it should only take one.

Look at the condition that allows the AI to make it's move, then trace the logic that should switch it back to the players turn.

Have you spotted the problem and now trying to help me find it, while me still doing the work, or just suggestign where i should start?

Either way I can't find it.

Will return just breakout of the aichoosemovetwo function? If it lands me somewhere else then that might be the problem...

Yay! Thats the last time I recall a function instead of using a loop: FIXED:

Code:

int aichoosemove()
{
aiboard[0][0]=board[0];
aiboard[0][1]=board[1];
aiboard[0][2]=board[2];
aiboard[1][0]=board[3];
aiboard[1][1]=board[4];
aiboard[1][2]=board[5];
aiboard[2][0]=board[6];
aiboard[2][1]=board[7];
aiboard[2][2]=board[8];
gogo=0;

do{
    randint = (rand()%9);
 if (board[randint]==0)
 {
     aimove=randint;
     gogo=1;
 }
 }while(gogo=0);

     
aichoosemovetwo();
  
 board[aimove]=2;
 numove++;
 player=1;   
}