In this assignment you will write a program for a popular game Tic-Tac-Toe. Your program will generate a board with nine cells using the traditional 3 x 3 layout and ask each of two users to choose one cell at a time. The users take turns, and each user marks the board cells with a naught O or a cross X. The game continues until either one of the users won or all cells on the board are marked with O or X. The user won when the three marks (O or X) are located on one line horizontally, vertically, or diagonally as shown on the picture below:
| X | ||
| X | ||
| X |
| X | X | X |
| X | ||
| X | ||
| X |
There are 8 winning cases in total: 3 horizontally arranged marks, 3 vertically arranged marks, and two diagonally arranged marks. The program writes who is the winner or it is a time. After that it will ask the users if they want to play again. Here are the snippets of the program output, be aware that your program output should match this format exactly. Please read the instruc!ons carefully and completely before starting to work on your program!
In the beginning a program should output the following messages and draws the board:
Welcome to TIC-TAC-TOE Game!
A B C
+---+---+---+
1| | | |
+---+---+---+
2| | | |
+---+---+---+
3| | | |
+---+---+---+
Bob, X: Enter a cell [A-C][1-3]:
If the user (the default first user is Bob) chose cell a1, the program updates the board and produces the following output:
A B C
+---+---+---+
1| X | | |
+---+---+---+
2| | | |
+---+---+---+
3| | | |
+---+---+---+
Alice, O: Enter a cell [A-C][1-3]:
If the user (the default second user is Alice) chose cell a1, the program does not update the board because this cell is already marked with an X. It asks the user to enter valid input in the following way:
You did not choose correctly.
Alice, O: Enter a cell [A-C][1-3]:
Notice that the second sentence is the same prompt used before. If the user (Alice or Bob) does not choose valid input, the program outputs the same messages as before until the user enters valid input. Valid input is a two-character string, which has the first character a letter A, B, or C (uppercase or lowercase) and the second character is 1, 2, or 3. The program should analyze if input is valid or invalid.
If Alice enters b2, the programs updates the board and produces the following output:
A B C
+---+---+---+
1| X | | |
+---+---+---+
2| | O | |
+---+---+---+
3| | | |
+---+---+---+
Bob, X: Enter a cell [A-C][1-3]:
As you can see, the program makes turns for players: after Bob chose a cell, Alice chooses a cell, and after Alice chose a cell, Bob chooses a cell. When the game is over, the program prints one of the following messages:
Bob is a winner!
Would you like to play again? [Y/N]
or
Alice is a winner!
Would you like to play again? [Y/N]
or
It is a tie!
Would you like to play again? [Y/N]
If the user types 'Y' or y the program starts a new game, draws the empty board, and prints the following message again:
A B C
+---+---+---+
1| | | |
+---+---+---+
2| | | |
+---+---+---+
3| | | |
+---+---+---+
Bob, X: Enter a cell [A-C][1-3]:
Otherwise it prints the following new message and terminates:
Goodbye!
In this assignment you need to create two classes Board and Player, each class should be written in its own file named board.py and player.py. They should be located in the same directory as the main program tictac.py.
Class Board should have six methods init, get_winner, set, isempty, isdone, and show. Please read the following code and instructions carefully. You can type or copy and paste this code into your file board.py. The file board.py should be located in the same directory as tictac.py (the main program) and player.py.
class Board:
def __init__(self):
# board is a list of cells that are represented
# by strings (" ", "O", and "X")
# initially it is made of empty cells represented
# by " " strings
self.sign = " "
self.size = 3
self.board = list(self.sign * self.size**2)
# the winner's sign O or X
self.winner = ""
def get_size(self):
# optional, return the board size (an instance size)
def get_winner(self):
# return the winner's sign O or X (an instance winner)
def set(self, cell, sign):
# mark the cell on the board with the sign X or O
# you need to convert A1, B1, ..., C3 cells into index values from 1 to 9
# you can use a tuple ("A1", "B1",...) or a dictionary to obtain indexes
# this implementation is up to you
def isempty(self, cell):
# return True if the cell is empty (not marked with X or O)
def isdone(self):
done = False
# check all game terminating conditions, if one of them is present, assign the var done to True
# depending on conditions assign the instance var winner to O or X
return done
def show(self):
# draw the board
A class Player should have four methods init, get_sign, get_name and choose. Please read the code and instruc!ons carefully. You can type or copy and paste this code into your file player.py. The file player.py should be located in the same directory as tictac.py (the main program) and board.py.
class Player:
def __init__(self, name, sign):
self.name = name # player's name
self.sign = sign # player's sign O or X
def get_sign(self):
# return an instance sign
def get_name(self):
# return an instance name
def choose(self, board):
# prompt the user to choose a cell
# if the user enters a valid string and the cell on the board is empty, update the board
# otherwise print a message that the in put is wrong and rewrite the prompt
# use the methods board.isempty(cell), and board.set(cell, sign)
In the main program tictac.py write the following code. Your code should match this code precisely!!!
# author:
# date:
# file: tictac.py a Python program that implements
a tic-tac-toe game
# input: user responses (strings)
# output: interactive text messages and a tic-tac-toe boardfrom board import Board
from player import Player
# main program
print("Welcome to TIC-TAC-TOE Game!")
while True:
board = Board()
player1 = Player("Bob", "X")
player2 = Player("Alice", "O")
turn = True
while True:
board.show()
if turn:
player1.choose(board)
turn = False
else:
player2.choose(board)
turn = True
if board.isdone():
break
board.show()
if board.get_winner() == player1.get_sign():
print(f"{player1.get_name()} is a winner!")
elif board.get_winner() == player2.get_sign():
print(f"{player2.get_name()} is a winner!")
else:
print("It is a tie!")
ans = input("Would you like to play again? [Y/N]\n").upper()
if (ans != "Y"):
break
print("Goodbye!")