Tic Tac Toe

A N*N Tic Tac Toe Game Written In Python.

Python Version: 3.8.5

How to run the Game

At the project root, run python3 main.py and follow the on-screen instructions.

How to run tests

At the project root, run python3 test_tic_tac_toe_unittest.py and follow the on-screen instructions. A github workflow configutaion file has been created to run tests when pushing and committing code to the main branch.

Features

N*N board size
Play with computer

Steps To Play The Game

Enter the size of the Tic Tac Toe Board (Minimum size is 3)
Set Player One
Set Player Two
Set 1 for Player One two make the first move and 2 for the Second Player
Set name COMP for any of the player to play with computer
Enter the valid and available numbers marked inside the tic tac toe board cells to make move

Initializing The Game

game = TicTacToe()

Setting the Tic Tac Toe Borad Size:

game.set_board_size(size=3)

If the size if invalid number or less than 3 ValueError.

Setting Players

game.set_player_one(name="John")
game.set_player_two(name="Doe")

In case of same name for both the players or an empty name an Exception will be raised. To play with computer set name as COMP.

Selecting a player to make the first move

game.first_choice_player(player='1')

pass 1 for the player one and 2 for the player two. Any other value will raise ValueError.

Drawing the Tic Tac Toe Board To Terminal

game.draw_board()

Get size of the board

game.get_board_size()

Showing Instructions

game.show_instructions()

Prints instrcutions to the terminal window.

Getting the player who needs to make the current move

game.get_turn()

Check if a choice is valid:

game.is_choice_valid(choice='1')

Returns True in case of a valid choice else False. If board size is 3 then a choice should from 1,2,3,4,5,6,7,8,9 to be valid.

Check if a choice is available:

game.is_choice_available(choice='1')

Check is a choice choosen by the player is available and not taken by the other player.

Making Move/Choice

game.mark_choice(choice='1')

To make a move or choice.

Checking if the game is won

game.get_winner()

Returns a tuple (True/False,'Name of the winner')

Get Winning Combinations

game.get_winning_combinations()

Return a list of winning combinations in the form of tuples of length equal to the size of the board. Ex: [('1','2','3'),('4','5','6')]

Get Available Combinations

game.get_available_combinations()

Return a list of available combinations in the form of tuples of length equal to the size of the board. Ex:Ex: [('1','2','3'),('4','5','6')]

Get Computer Choice

game.get_computer_choice()

Returns a choice from the list of available choices. This method is useful when any of the player is COMP

Get Weight Of A Combination

game.get_combination_weight(combination=('1','2','3'),search_symbol='X')

Valid values for search_symbol are X and O. A combination with higher weight has the more chance of winning the game. This method is used for computer making the choice. If search_symbol is X and size of the board is 4 then

X X X _ weight=2
X _ _ O weight=-1
X _ _ X weight=0
O _ _ _ weight = -1
X X _ _ weight = 1

Interface

class TicTacToeInterface:

    def set_board_size(self, size: int):
        """This will set the size of the tic tac toe board. if size is 4 then the board size will 4*4 totaling to 16 cells"""
        pass

    def set_player_one(self, name: str):
        """Set the name of the player one. Cannot be same name as the second player"""
        pass

    def set_player_two(self, name: str):
        """Set the name of the second player. Cannot be same name as the first player"""
        pass

    def show_instructions():
        """Print out the game instructions to terminal"""
        pass

    def first_choice_player(self, player: str):
        """Set which player to make the first move/choice. 1 to select first player and 2 for the second player"""
        pass

    def get_turn(self) -> str:
        """Get the current turn's player who has to make choice. Returns the name of the player"""
        pass

    def get_player_one(self) -> str:
        """Get name of the player one"""
        pass

    def get_player_two(self) -> str:
        """Get name of the second player"""
        pass

    def draw_board(self):
        """Print out the tic tac toe board of given size to the terminal with selected choices"""
        pass

    def get_available_choices(self) -> list:
        """Get a list of choices avaiable for the player to select from"""
        pass

    def is_choice_available(self, choice: str) -> bool:
        """Check if a choice is available to be selected by the player"""
        pass

    def is_choice_valid(self, choice: str) -> bool:
        """Check if the choice selected by the player is valid. The choice must be one of the values from the list returned from get_available_choices"""
        pass

    def mark_choice(self, choice):
        """Mark choice on to the game board selected my the current player. Choice should be valid and available"""
        pass

    def get_winner(self) -> "tuple[bool, str]":
        """Get game status and winner in the form a tuple. Needs to be called after every mark_choice call"""
        pass

    def get_board_size(self) -> int:
        """Get the size of the board"""
        pass

    def get_winning_combinations(self) -> "list[tuple]":
        """Get a list of winning combination in the form of tuples"""
        pass

    def get_available_combinations(self) -> "list[tuple]":
        """Get a list of available combinations in the form of tuples"""
        pass

    def get_combination_weight(self, combination: "tuple[str]", search_symbol: str) -> int:
        """Get the weight of a combination in the game. Weight is calculated based on the number of consicutive repetetions of the search_symbol"""
        pass

    def get_computer_choice(self) -> str:
        """Get the computer's choice/move"""
        pass

harishdurga / python-tic-tac-toe