Question

Implement a tic-tac-toe game.

Currently, if the variables provided in main are commented out, the program will compile. Complete the specifications for each function. As you develop the program, implement one function at a time, and test that function. The provided comments provide hints as to what each function should do and when each should be called. Add variables where you see fit.

Implementation Strategies:

• The template has variables and two global constants for you to utilize.

• The template has comments to help you develop the necessary algorithm for 2 users playing tic-tac-toe on a computer. Use these comments along with the function descriptions (comments) to help develop your program. One or more lines of your code should exist below each comment. Remove the TODO part when you have completed that step.

• DO NOT try to implement the entire game at once. Instead, develop and test one function at a time. Understand how to walk through your code by hand as well as executing it in unit tests.

• The system will test your functions as you attempt to complete each. In other words, submit as you go. Use the submission feedback and walk through your code to fix problems.

• Submit and achieve a full score on each function before implementing the main game algorithm.

• Suggested order of completion:

  1. initVector: Define, test, and submit this function before moving on. (Should now have 2 points.)

  2. Now call initVector and drawBoard functions where told to in main (before getting first play) to see your first board output. Submit. (Should now have 4 points.)

  3. convertPosition: You'll need this to get the first play, so define, test, and submit this one before tackling getPlay function. (Should now have 6 points.)

  4. validPlacement: Again, you'll need this to get the first play, so define, test, and submit this one before tackling getPlay function. (Should now have 8 points.)

  5. getPlay: Now that you have convertPosition and validPlacement working, use these functions to help you define the getPlay function. Be sure this function continues to ask the user for input (does not return) until they provide a valid board position. Test and submit for feedback. (Should now have 10 points.)

  6. Now call getPlay function in main to get just 1 play. Use the return value to place an X in that spot and call drawBoard again. Do not try to get the loop working yet. Just call getPlay once. (Should now have 12 points.)

  7. gameWon: Define, test, and submit this function. (Should now have 16 points.)

  8. boardFull: Define, test, and submit this function. (Should now have 18 points.)

  9. You now have all functions fully tested and working. Go ahead and complete the main function. Get the loop working. Figure out how to switch who's turn it is and implement that. Output the winner or tie game after the loop exits. (Should now have full points!)

Tie Game Example:

  a  |  b  |  c  
-----|-----|-----
  d  |  e  |  f  
-----|-----|-----
  g  |  h  |  i  

Please choose a position: 
  X  |  b  |  c  
-----|-----|-----
  d  |  e  |  f  
-----|-----|-----
  g  |  h  |  i  

Please choose a position: 
  X  |  O  |  c  
-----|-----|-----
  d  |  e  |  f  
-----|-----|-----
  g  |  h  |  i  

Please choose a position: 
  X  |  O  |  c  
-----|-----|-----
  d  |  X  |  f  
-----|-----|-----
  g  |  h  |  i  

Please choose a position: 
  X  |  O  |  c  
-----|-----|-----
  d  |  X  |  f  
-----|-----|-----
  g  |  h  |  O  

Please choose a position: 
  X  |  O  |  c  
-----|-----|-----
  d  |  X  |  X  
-----|-----|-----
  g  |  h  |  O  

Please choose a position: 
  X  |  O  |  c  
-----|-----|-----
  O  |  X  |  X  
-----|-----|-----
  g  |  h  |  O  

Please choose a position: 
  X  |  O  |  X  
-----|-----|-----
  O  |  X  |  X  
-----|-----|-----
  g  |  h  |  O  

Please choose a position: 
  X  |  O  |  X  
-----|-----|-----
  O  |  X  |  X  
-----|-----|-----
  O  |  h  |  O  

Please choose a position: 
  X  |  O  |  X  
-----|-----|-----
  O  |  X  |  X  
-----|-----|-----
  O  |  X  |  O  

No one wins

in c++ please

existing code :

#include <vector>
#include <iostream>

using namespace std;

/// @brief Draws the provided tic-tac-toe board to the screen
// @param board is the tic-tac-toe board that should be drawn
void drawBoard(const vector < char >&gameBoard) {
for (int i = 0; i < 9; i += 3) {
cout << " " << gameBoard.at(i) << " | " << gameBoard.at(i + 1) << " | "
<< gameBoard.at(i + 2) << " " << endl;
if (i < 6) {
cout << "-----|-----|-----" << endl;
}
}
cout << endl;
  
return;
}

/// @brief Fills vector with characters starting at lower case a.
///
/// If the vector is size 3 then it will have characters a to c.
/// If the vector is size 5 then it will have characters a to e.
/// If the vector is size 26 then it will have characters a to z.
///
/// @param v the vector to initialize
/// @pre-condition the vector size will never be over 26
void initVector(vector <char> &v) {
  
// TODO: implement function
return;
}

/// @brief Converts a character representing a cell to associated vector index
/// @param the position to be converted to a vector index
/// @return the integer index in the vector, should be 0 to (vector size - 1)
int convertPosition(char boardPosition) {

// TODO: implement function
return -1;
}

/// @brief Predicate function to determine if a spot in board is available.
/// @param board the current tic-tac-toe board
/// @param position is an index into vector to check if available
/// @return true if position's state is available (not marked) AND is in bounds
bool validPlacement(const vector<char> &gameBoard, int positionIndex) {

// TODO: implement function
return false;
}

/// @brief Acquires a play from the user as to where to put her mark
///
/// Utilizes convertPosition and validPlacement functions to convert the
/// user input and then determine if the converted input is a valid play.
/// Continues asking for a position until a valid position has been entered.
///
/// @param board the current tic-tac-toe board
/// @return an integer index in board vector of a chosen available board spot
int getPlay(const vector<char> &gameBoard) {

// TODO: implement function
char boardPosition = ' ';
  
cout << "Please choose a position: ";
  
  
return -1;
}

/// @brief Predicate function to determine if the game has been won
///
/// Winning conditions in tic-tac-toe require three marks from same
/// player in a single row, column or diagonal.
///
/// @param board the current tic-tac-toe board
/// @return true if the game has been won, false otherwise
bool gameWon(const vector<char> &gameBoard) {
  
// TODO: implement function
return false;
}

/// @brief Predicate function to determine if the board is full
/// @param board the current tic-tac-toe board
/// @return true iff the board is full (no cell is available)
bool boardFull(const vector<char> &gameBoard) {

// TODO: implement function
return false;
}

// Global constants for player representation
const int PLAYER1 = 0;
const int PLAYER2 = 1;

int main() {
// Variables that you may find useful to utilize
vector<char> gameBoard(9);
int curPlay;
int whosTurn = PLAYER1; // Player 1 always goes first and is 'X'

/// TODO: Initialize board to empty state

/// TODO: Display empty board

/// TODO: Play until game is over

/// TODO: Get a play

/// TODO: Set the play on the board

/// TODO: Switch the turn to the other player
  
/// TODO: Output the updated board

/// TODO: Determine winner and output appropriate message

return 0;
}

Answer 1

Code:

#include <vector>
#include <iostream>
using namespace std;

void drawBoard(const vector < char >&gameBoard) {
for (int i = 0; i < 9; i += 3) {
cout << " " << gameBoard.at(i) << " | " << gameBoard.at(i + 1) << " | "
<< gameBoard.at(i + 2) << " " << endl;
if (i < 6) {
cout << "-----|-----|-----" << endl;
}
}
cout << endl;

return;
}

void initVector(vector <char> &v) {
for (unsigned i = 0; i < v.size(); ++i) {
v.at(i) = static_cast<char>(97 + i);
}

return;
}

int convertPosition(char boardPosition) {
return static_cast<int> (boardPosition) - 97;
}

bool validPlacement(const vector<char> &gameBoard, int positionIndex) {

if (gameBoard.at(positionIndex) != 'X' && gameBoard.at(positionIndex) != 'O') {
return true;
}
else {
return false;
}
}

int getPlay(const vector<char> &gameBoard) {

char position = ' ';
unsigned int conversion;

cout << "Please choose a position: " << endl;
cin >> position;
conversion = convertPosition(position);

while (conversion >= gameBoard.size()) {
cout << "Please choose a position: " << endl;
cin >> position;
conversion = convertPosition(position);
}

while (!validPlacement(gameBoard, conversion)) {
cout << "Please choose a position: " << endl;
cin >> position;
conversion = convertPosition(position);
}

return convertPosition(position);
}

bool gameWon(const vector<char> &gameBoard) {

if ((gameBoard.at(0) == gameBoard.at(1) && gameBoard.at(1) == gameBoard.at(2)) ||
(gameBoard.at(3) == gameBoard.at(4) && gameBoard.at(4) == gameBoard.at(5)) ||
(gameBoard.at(6) == gameBoard.at(7) && gameBoard.at(7) == gameBoard.at(8)) ||
(gameBoard.at(0) == gameBoard.at(3) && gameBoard.at(3) == gameBoard.at(6)) ||
(gameBoard.at(1) == gameBoard.at(4) && gameBoard.at(4) == gameBoard.at(7)) ||
(gameBoard.at(2) == gameBoard.at(5) && gameBoard.at(5) == gameBoard.at(8)) ||
(gameBoard.at(0) == gameBoard.at(4) && gameBoard.at(4) == gameBoard.at(8)) ||
(gameBoard.at(2) == gameBoard.at(4) && gameBoard.at(4) == gameBoard.at(6))) {
return true;
}
else {
return false;
}
}

bool boardFull(const vector<char> &gameBoard) {

bool place0 = validPlacement(gameBoard, 0);
bool place1 = validPlacement(gameBoard, 1);
bool place2 = validPlacement(gameBoard, 2);
bool place3 = validPlacement(gameBoard, 3);
bool place4 = validPlacement(gameBoard, 4);
bool place5 = validPlacement(gameBoard, 5);
bool place6 = validPlacement(gameBoard, 6);
bool place7 = validPlacement(gameBoard, 7);
bool place8 = validPlacement(gameBoard, 8);

if (!place0 & !place1 & !place2 & !place3 & !place4 &
!place5 & !place6 & !place7 & !place8) {
return true;
}

return false;
}

int main() {
vector<char> gameBoard(9);
int curPlay;
int whosTurn = 0;
bool winner;
bool full;

initVector(gameBoard);
drawBoard(gameBoard);
winner = gameWon(gameBoard);
full = boardFull(gameBoard);

while (!winner & !full) {
curPlay = getPlay(gameBoard);
if (whosTurn % 2 == 0) {
gameBoard.at(curPlay) = 'X';
}
else {
gameBoard.at(curPlay) = 'O';
}
drawBoard(gameBoard);
cout << endl;
++whosTurn;
winner = gameWon(gameBoard);
full = boardFull(gameBoard);
}

if (winner) {
if (whosTurn % 2 == 0) {
cout << "Player 2 Wins!!";
}
else {
cout << "Player 1 Wins!!";
}
}
else if (full) {
cout << "No one wins";
}

return 0;
}