Learn how you can become a Python programmer in just 12 weeks.

    We respect your privacy. Unsubscribe at anytime.

    Python Project: Interactive Board Game (Importance of Design)

    Project Description

    To implement an interactive board game in Python you can consider the following board.

    |O|   |   |   |  |X|

    The player is O and the goal is to not get hit by X.

    The player can move either 1 or 2 moves to left or right, but only inside the board.

    The computer will make a similar move with X.

    If the player lands on X or if the computer lands on O the player loses.

    Watch tutorial!

    Importance of Design

    Making a design of your Python project before starting to code is crucial for several reasons, especially when you make an interactive board game in Python.

    1. Clarifying the project requirements. Creating a design document helps to identify the requirements of the project, the data that needs to be collected or generated, and the expected outputs. This can prevent misunderstandings and ensure that everyone involved in the project is on the same page.
    2. Structuring the project. Designing your project helps you break it down into manageable parts and plan out how those parts will interact. This can help you identify potential issues early on and make sure that the project is structured in a way that will be easy to maintain and expand.
    3. Saving time. A well-designed project can save a lot of time in the long run by reducing the number of errors and simplifying the debugging process. By planning ahead, you can ensure that the project is built in a way that is efficient, maintainable, and scalable.
    4. Facilitating collaboration. When working on a project with others, a design document can help ensure that everyone has a clear understanding of what is being built and how it will work. This can facilitate collaboration and help avoid miscommunications.

    A great way to break things down is to think about the logical steps in the process of the game.

    One way to do that is as follows.

    1. Represent the board
    2. Display the board
    3. Input from the user (with validation)
    4. Check if the user lost
    5. Update the board
    6. Let computer move
    7. Check if the computer won
    8. Update board for computer

    The next part is to implement each part of the steps and finally combine them. A great way to do that is to keep each step in one or more functions.

    Step 0 Represent the board

    While this seems to be a simple decision, it often has the biggest impact on the code. Said differently, the code of the interactive board game in Python will be influenced by this decision.

    How you represent the board will have an impact on most other parts of your implementation.

    A simple way to do it is as follows, but still, consider that it will have an impact on the rest of the code you need to write.

    board = ['O', ' ', ' ', ' ', ' ', 'X']

    We have it as a list of characters using the symbols O and X and space for empty.

    Step 1 Display the board

    This can be done in many ways, but here we just keep it simple displaying output with print statements.

    # Please Notice that this is only used in Notebooks.
    from IPython.display import clear_output
    def display_board(board):
        length = len(board)
        print('-'*(length*2 + 1))
        for item in board:
            print('|', item, sep='', end='')
        print('-'*(length*2 + 1))

    As mentioned in the comment, the clear_output can only be used in a Notebook. If you do not use Notebooks, then you should remove the import and the call to.

    Step 2 Input from the user with validation

    Human-computer interaction is one of the most difficult parts to implement.


    Users may not understand what to do, or give input in the wrong format or way.

    We keep it simple here and continue to ask the user until the input is a valid move.

    One way to do that is by using helper functions as follows by using conditional statements.

    def get_position(board, marker):
        return board.index(marker)
    def valid_move(board, input_str):
        if input_str not in ['-2', '-1', '1', '2']:
            return False
        move = int(input_str)
        pos = get_position(board, 'O')
        if pos + move < 0:
            return False
        if pos + move >= len(board):
            return False
        return True
    def user_input(board):
        while True:
            input_str = input('Choose move (-2, -1, 1, 2): ')
            if valid_move(board, input_str):
                return int(input_str)
            print('invalid move')

    We use an infinite while loop to get input.

    Step 3 Check if user lost

    Next we need to check if the user lost.

    This can be done as follows.

    def game_done(board, move, marker):
        pos = get_position(board, marker)
        if board[pos + move] != ' ':
            return True
            return False

    Step 4 Update the board

    Then we need to update the board.

    def update_board(board, move, marker):
        pos = get_position(board, marker)
        board[pos] = ' '
        board[pos + move] = marker
        return board

    Step 5 Make a computer move

    This requires randomness. Python has standard library for that.

    How can you make a valid random move.

    1. Make a random move (not necessarily valid)
    2. Check if valid, if not valid go to 1 else done.

    This can be implemented as follows.

    from random import randrange
    def get_random_move():
        while True:
            random_move = randrange(-2, 3)
            if random_move in [-2, -1, 1, 2]:
                return random_move
    def get_computer_move(board):
        pos = get_position(board, 'X')
        while True:
            move = get_random_move()
            if pos + move < 0:
            if pos + move >= len(board):
            return move

    It is also using continue as a great way to keep the flow simple in the while loop.

    Step 6 Check if computer won

    Now wait a minute.

    How is the diffirent from check if player lost?

    It is only about the marker.

    Luckily, we implemented it in a way where we set the marker as an argument.

    This will make sense when you see the final code.

    Step 7 Update board for computer

    Again, this is just as updating it for the player, because we made the marker an argument.

    Putting it all together

    Now this is the power of modular programming.

    Creating the final program is simple.

    board = ['O', ' ', ' ', ' ', ' ', 'X']
    moves = 0
    while True:
        move = user_input(board)
        if game_done(board, move, 'O'):
            print('You lost')
        board = update_board(board, move, 'O')
        moves += 1
        computer_move = get_computer_move(board)
        if game_done(board, computer_move, 'X'):
            print('Computer move', computer_move)
            print('You made', moves, 'moves')
        board = update_board(board, computer_move, 'X')

    Now how about that.

    Want more Python projects?

    This is part of 19 Python Projects and you can create this Tic Tac Toe game that has some great insights in keeping code simple.

    Python for Finance: Unlock Financial Freedom and Build Your Dream Life

    Discover the key to financial freedom and secure your dream life with Python for Finance!

    Say goodbye to financial anxiety and embrace a future filled with confidence and success. If you’re tired of struggling to pay bills and longing for a life of leisure, it’s time to take action.

    Imagine breaking free from that dead-end job and opening doors to endless opportunities. With Python for Finance, you can acquire the invaluable skill of financial analysis that will revolutionize your life.

    Make informed investment decisions, unlock the secrets of business financial performance, and maximize your money like never before. Gain the knowledge sought after by companies worldwide and become an indispensable asset in today’s competitive market.

    Don’t let your dreams slip away. Master Python for Finance and pave your way to a profitable and fulfilling career. Start building the future you deserve today!

    Python for Finance a 21 hours course that teaches investing with Python.

    Learn pandas, NumPy, Matplotlib for Financial Analysis & learn how to Automate Value Investing.

    “Excellent course for anyone trying to learn coding and investing.” – Lorenzo B.

    Leave a Comment