How to Create a Tic-Tac-Toe Game in Python?


Allow us to create a easy Tic Tac Toe recreation in Python. It is going to mean you can to increase recreation good judgment and know the way to construction code.

Gaming is among the leisure that people have. We will to find various kinds of video games on the net, cellular, desktop, and many others. We don’t seem to be right here to make a kind of heavy video games now. We’re going to create a CLI tic-tac-toe recreation the usage of Python.

If you happen to don’t seem to be aware of Tic Tac Toe, play it visually right here to perceive. Don’t concern, even supposing you don’t comprehend it, we’re going to see it.

Tic Tac Toe

The academic is split into 3 other sections. Within the first phase, you’ll get to understand how to play the tic-tac-toe recreation. After that, we will be able to see an set of rules that is helping us to get a hold of the sport good judgment. In any case, we will be able to see the structured code and its clarification.

It’s possible you’ll skip the primary phase when you already understand how to play Tic Tac Toe.

So, with out additional ado, let’s dive into our first phase.

Enjoying Tic Tac Toe

There shall be two gamers in a recreation. Two indicators constitute every participant. The overall indicators used in the sport are and O. In any case, there shall be a board with 9 containers.

See the tic-tac-toe board visually.

Tic Tac Toe Board
Tic Tac Toe Board

The gameplay shall be as follows.

  • First, one consumer will position their signal in one of the most to be had empty containers.
  • Subsequent, the second one consumer will position their signal in one of the most to be had empty containers.
  • The function of the gamers is to position their respective indicators totally row-wise or column-wise, or diagonally.
  • The sport is going on till a participant wins the sport or it ended up in a draw through filling all containers with out a successful fit.

Let’s see some gameplays visually.

Tic Tac Toe Win Gameplay
Tic Tac Toe Win Gameplay

The participant wins the sport in the above gameplay. All containers diagonally fill with indicators. So, the respective participant wins the sport.

There are a overall of 8 techniques to organize the similar signal and win the sport. Let’s see the entire 8 preparations that may win the sport.

Tic Tac Toe Winning Arrangements
Tic Tac Toe Profitable Preparations

And after all, a draw fills the board with none successful association. I am hoping you know how to Tic Tac Toe now.

Now, it’s playtime for you. It’s possible you’ll move right here and play it to perceive the gameplay totally. Depart it if you already have it.

Now, it’s time to transfer the set of rules phase.

 Set of rules

We will be able to now speak about the set of rules to write the code. This set of rules will mean you can to write code in any programming language of your selection. Let’s see the way it’s completed.

  • Create a board the usage of a 2-dimensional array and initialize every component as empty.
    • You’ll be able to constitute empty the usage of any image you favor. Right here, we’re going to use a hyphen. '-'.
  • Write a serve as to take a look at whether or not the board is crammed or no longer.
    • Iterate over the board and go back false if the board accommodates an empty signal or else go back true.
  • Write a serve as to take a look at whether or not a participant has gained or no longer.
    • We have now to take a look at the entire probabilities that we mentioned in the former phase.
    • Take a look at for the entire rows, columns, and two diagonals.
  • Write a serve as to display the board as we will be able to display the board more than one instances to the customers whilst they’re taking part in.
  • Write a serve as to get started the sport.
    • Make a selection the primary flip of the participant randomly.
    • Write a vast loop that breaks when the sport is over (both win or draw).
      • Display the board to the consumer to choose the spot for your next step.
      • Ask the consumer to input the row and column quantity.
      • Replace the spot with the respective participant signal.
      • Take a look at whether or not the present participant gained the sport or no longer.
      • If the present participant gained the sport, then print a successful message and smash the limitless loop.
      • Subsequent, take a look at whether or not the board is crammed or no longer.
      • If the board is crammed, then print the draw message and smash the limitless loop.
    • In any case, display the consumer the overall view of the board.

You can be in a position to visualize what’s taking place. Don’t concern, even supposing you didn’t comprehend it totally. You’ll get extra readability while you see the code.

So, let’s leap into the code phase. I suppose you’ve got Python put in to your PC to check out the code.

Code

Pass during the underneath code.

import random


elegance TicTacToe:

    def __init__(self):
        self.board = []

    def create_board(self):
        for i in vary(3):
            row = []
            for j in vary(3):
                row.append('-')
            self.board.append(row)

    def get_random_first_player(self):
        go back random.randint(0, 1)

    def fix_spot(self, row, col, participant):
        self.board[row][col] = participant

    def is_player_win(self, participant):
        win = None

        n = len(self.board)

        # checking rows
        for i in vary(n):
            win = True
            for j in vary(n):
                if self.board[i][j] != participant:
                    win = False
                    smash
            if win:
                go back win

        # checking columns
        for i in vary(n):
            win = True
            for j in vary(n):
                if self.board[j][i] != participant:
                    win = False
                    smash
            if win:
                go back win

        # checking diagonals
        win = True
        for i in vary(n):
            if self.board[i][i] != participant:
                win = False
                smash
        if win:
            go back win

        win = True
        for i in vary(n):
            if self.board[i][n - 1 - i] != participant:
                win = False
                smash
        if win:
            go back win
        go back False

        for row in self.board:
            for merchandise in row:
                if merchandise == '-':
                    go back False
        go back True

    def is_board_filled(self):
        for row in self.board:
            for merchandise in row:
                if merchandise == '-':
                    go back False
        go back True

    def swap_player_turn(self, participant):
        go back 'X' if participant == 'O' else 'O'

    def show_board(self):
        for row in self.board:
            for merchandise in row:
                print(merchandise, finish=" ")
            print()

    def get started(self):
        self.create_board()

        participant = 'X' if self.get_random_first_player() == 1 else 'O'
        whilst True:
            print(f"Participant participant flip")

            self.show_board()

            # taking consumer enter
            row, col = checklist(
                map(int, enter("Input row and column numbers to repair spot: ").cut up()))
            print()

            # solving the spot
            self.fix_spot(row - 1, col - 1, participant)

            # checking whether or not present participant is gained or no longer
            if self.is_player_win(participant):
                print(f"Participant participant wins the sport!")
                smash

            # checking whether or not the sport is draw or no longer
            if self.is_board_filled():
                print("Fit Draw!")
                smash

            # swapping the flip
            participant = self.swap_player_turn(participant)

        # appearing the overall view of board
        print()
        self.show_board()


# beginning the sport
tic_tac_toe = TicTacToe()
tic_tac_toe.get started()

Take a look at the pattern output of the code.

$ python tic_tac_toe.py 
Participant X flip
- - -
- - -
- - -
Input row and column numbers to repair spot: 1 1

Participant O flip
X - -
- - -
- - -
Input row and column numbers to repair spot: 2 1

Participant X flip
X - -
O - -
- - -
Input row and column numbers to repair spot: 1 2

Participant O flip
X X -
O - -
- - -
Input row and column numbers to repair spot: 1 3

Participant X flip
X X O
O - -
- - -
Input row and column numbers to repair spot: 2 2

Participant O flip
X X O
O X -
- - -
Input row and column numbers to repair spot: 3 3

Participant X flip
X X O        
O X -        
- - O
Input row and column numbers to repair spot: 3 2

Participant X wins the sport!

X X O
O X -
- X O

Some primary issues that mean you can perceive the construction of the code.

  • We have now used a elegance to have the entire strategies in one position. It might probably simply be a reusable package deal in another code as neatly.
  • Subsequent, we’ve outlined other purposes for every accountability, even supposing it’s a small process. It is helping to handle the code conveniently.
  • The above two approaches assist us replace the app without problems if we wish to replace the sport.

Be at liberty to adapt the construction and make stronger it according to your undertaking. Structuring the code isn’t restricted.

Ultimate Phrases

Hurray! 😎 You might have created a recreation totally from scratch. It’s not one of the most visible video games that we play day by day. However it is helping you to write good judgment and handle blank construction in code. Practice identical pointers to create some attention-grabbing video games like this. You’ll be able to to find identical video games when you return some years to your youth.

Satisfied Coding! 👩‍💻

Subsequent, discover how to create quantity guessing recreation.

Related Articles

Leave a Reply

Your email address will not be published.

Back to top button