Выберите X или O, чтобы переместить крестики-нолики

Question

Я делаю игру Tic Tac Toe, и я создал функцию, которая вставляет X или O в мой массив.Я столкнулся с одной проблемой с моим дизайном.Я вызываю функцию, чтобы сделать ход для X, но когда настанет следующий ход игроков, как мне сделать так, чтобы он вызывал O?

Есть ли способ после того, как я поставил makeMove (), я могу просто как-то вызвать еговзять в свою очередь O вместо X. Потому что, как вы можете видеть, если я сделаю X, он просто всегда будет запрашивать X, а не O. Как я могу сделать выбор, выбрав X или O свою очередь?

Проблема в том, что мне нужна только одна функция, которая делает ходы.

int main()
{
    while(SOME CONDITION HERE)
    {
        printBoard();
        cout << "Player X please choose a position: ";
        makeMove('X');
        cout << "Player O please choose a position: ";
        makeMove('O');
    }
}


int makeMove(char marker)
{
    int choosePosition = 0;

    cin >> choosePosition;

    ticTacBoard[choosePosition - 1] = marker;
}

Answer 1

Начните с этого:

int main()
{
    while(SOME CONDITION HERE)
    {
        printBoard();
        cout << "Player X please choose a position: ";
        makeMove('X');
        cout << "Player O please choose a position: ";
        makeMove('O');
    }
}


int makeMove(char marker)
{
    int choosePosition = 0;

    cin >> choosePosition;

    ticTacBoard[choosePosition - 1] = marker;
}

Обратите внимание, что вы захотите изменить деталь SOME CONDITION HERE, но вы можете быстро заменить ее на 1 и получить то же поведение, что и у вашего текущегосценарий (на самом деле, немного лучше).

Но в конечном итоге вы захотите поместить туда что-то, что имеет смысл - то, что скажет программе прекратить запрашивать у игроков позиции и, скажем, объявить победителя..

---

Ниже приведен более простой способ сделать то же самое:

int main()
{
    while(SOME CONDITION HERE)
    {
        printBoard();

        makeMove('X');
        makeMove('O');
    }
}


int makeMove(char marker)
{
    cout << "Player " << marker << " please choose a position: ";

    int choosePosition = 0;

    cin >> choosePosition;

    ticTacBoard[choosePosition - 1] = marker;

    return 0;
}

Обратите внимание на добавленный return 0 - если вы не хотите что-то возвращатьВы должны просто сделать makeMove return void, чтобы не запутаться.

Answer 2

http://scripts.franciscocharrua.com/javascript/tic-tac-toe/

Я добавил это на свой сайт несколько месяцев назад.Я признаю, что это может быть немного сложным, и в JavaScript, но это может помочь.

JS:

function tic_tac_toe(blank_token, player_tokens, artificial_intelligence)
{         
         this.board = [[blank_token, blank_token, blank_token],
                   [blank_token, blank_token, blank_token],
                   [blank_token, blank_token, blank_token]];

     this.blank_token = blank_token;
     this.player_tokens = player_tokens;         
     this.display_choice = function() {};
     this.declare_human_win = function() {};
     this.declare_computer_win = function() {};
     this.declare_tie = function() {};         
     this.artificial_intelligence = artificial_intelligence; 

     this.start = 
     function() 
     {                  
              //Randomly choose a token for the human player.
              var human_token_index = Math.floor(Math.random() * this.player_tokens.length);
              this.human_player = this.player_tokens[human_token_index];

              //Place the chosen token at the end of the array.
              this.player_tokens[human_token_index] = this.player_tokens[this.player_tokens.length - 1];
              this.player_tokens[this.player_tokens.length - 1] = this.human_player;

              //Randomly choose a different token for the computer player.
              var computer_token_index = Math.floor(Math.random() * (this.player_tokens.length - 1));
              this.computer_player = this.player_tokens[computer_token_index];                                    

              //Clear the board.
              for(var row = 0; row < 3; row++)
              for(var collumn = 0; collumn < 3; collumn++)
              {
                  this.place(this.blank_token, row, collumn);
              }   

              if(Math.random() < 0.5)
              {                    
                 this.turn = this.computer_player;
                 this.computer_turn();
              }
              else
              {
                 this.turn = this.human_player;
              }                           
     };

     //Returns the token of the winning player. 
     //If no one has won yet or the game is tied, returns the blank token.
     //Used in combination with blank_token_count() to determine if the game is tied.
     this.winner =
     function()
     {
              var winner = this.blank_token;

              //Check for 3 consecutive horisontal tokens.
              for(var row = 0; row < 3; row++)
              {
                  winner = this.board[row][0];
                  for(var collumn = 1; collumn < 3; collumn++)
                  {
                      if(this.board[row][collumn] != winner)
                      {
                         winner = this.blank_token;
                      }                        
                  }

                  if(winner != this.blank_token)
                  {
                     return(winner);
                  }                      
              }

              //Check for 3 consecutive vertical tokens.
              for(var collumn = 0; collumn < 3; collumn++)
              {
                  winner = this.board[0][collumn];
                  for(var row = 1; row < 3; row++)
                  {
                      if(this.board[row][collumn] != winner)
                      {
                         winner = this.blank_token;
                      }                               
                  }

                  if(winner != this.blank_token)
                  {
                     return(winner);
                  }                                            
              }

             //Check for 3 consecutive diagonal tokens.
             winner = this.board[0][0];
             for(var row = 1; row < 3; row++)
             {
                 if(this.board[row][row] != winner)
                 {
                    winner = this.blank_token;
                 }
             }

             if(winner != this.blank_token)
     {
        return(winner);
             }

             winner = this.board[0][2];
             for(var row = 1; row < 3; row++)
             {
                 if(this.board[row][2 - row] != winner)
                 {
                    winner = this.blank_token;
                 }
             }

             if(winner != this.blank_token)
     {
        return(winner);
             }

             return(winner);
     };                

     this.blank_token_count =
     function()
     {
              var blank_token_count = 0;

              for(var row = 0; row < 3; row++)
              for(var collumn = 0; collumn < 3; collumn++)
              {
                  if(this.board[row][collumn] == this.blank_token)
                  {
                     blank_token_count++;
                  }
              }

              return(blank_token_count);
     };

     this.computer_turn =
     function()
     {  
             //Lets the computer take its turn if the game is not over.
             if(this.turn != this.blank_token)
             {
                this.turn = this.computer_player;
                var computer_move = this.artificial_intelligence();
                this.place(this.computer_player, computer_move.row, computer_move.collumn);                                  
             }
     };

     this.human_turn = 
     function(row, collumn)
     {
             this.place(this.human_player, row, collumn);
             this.computer_turn();
     }

     this.place =
     function(token, row, collumn)
     {
              if(row < 3 && collumn < 3 && 
                ((this.turn == token && this.board[row][collumn] == this.blank_token) || token == this.blank_token))
              {                     
                 this.board[row][collumn] = token;
                 this.display_choice(token, row, collumn)

                 //Finishes the game in case a of a win or a tie.
                 //When the board is not being reset.
                 if(token != this.blank_token)
                 {
                    var winner_token = this.winner(); 

                    if(winner_token == this.human_player)
                    {
                       this.declare_human_win();
                       this.turn = this.blank_token;
                    }

                    if(winner_token == this.computer_player)
                    {
                       this.declare_computer_win();
                       this.turn = this.blank_token;
                    }

                    if(winner_token == this.blank_token && this.blank_token_count() == 0)
                    {
                       this.declare_tie();
                       this.turn = this.blank_token;
                    }

                    //Gives the human player a turn, if the game is not over.
                    if(this.turn == this.computer_player)
                    {
                       this.turn = this.human_player
                    }
                 }
              }
     };

}

Answer 3

Что-то вроде этого может работать ... просто обязательно используйте цикл для ходов.

char player = 'X';

while(...) {
  cout << "choose position...";
  makeMove(player);

  if(player == 'X')
    player = 'O';
  else
    player = 'X';
  ...
}

//in make move:
int makeMove(char player) {
  int choosePosition = 0;
  cin >> choosePosition;
  ticTacBoard[choosePosition - 1] = player;
}

Answer 4

Прежде всего, не вызывайте main() рекурсивно.Вместо этого используйте цикл.

Во-вторых, используйте переменную (например, player ниже), чтобы указать, чей это поворот.

Answer 5

Вы можете попробовать использовать аргумент:

int makeMove(char player);

makeMove('O');
makeMove('X');