Mastering Tic Tac Toe Game in React: A Comprehensive Guide

Have you ever wanted to build a tic tac toe game using React? If so, you're in the right place. In this blog post, we'll walk through the process of creating an interactive tic tac toe game in React from scratch. This guide is perfect for beginners who are just getting started with React and web development.

‍

Why Build a Tic Tac Toe Game?

Building a tic tac toe game is a great way to learn and practice your React skills. It's a simple game that everyone knows how to play, but it involves enough logic and interactivity to make it a challenging and rewarding project for a beginner. Plus, it's a lot of fun!

‍

Setting Up Your Environment

Before we start coding, we need to set up our development environment. First, you need to have Node.js and npm installed on your computer. If you don't have them yet, you can download them from the official Node.js website.

Once you have Node.js and npm installed, you can create a new React app using the Create React App command-line tool. Just open your terminal, navigate to the folder where you want to create your app, and run the following command:

Copy
1
2
         // Your JavaScript code with proper indentation here
       

This command will create a new folder named "tic-tac-toe" with a basic React app inside it. Navigate into this folder using the command cd tic-tac-toe, and then start the app by running npm start. You should see your new React app running in your browser.

‍

Creating the Board Component

Our tic tac toe game will consist of two main components: the Board component and the Square component. The Board component will represent the entire game board, and the Square component will represent a single cell on the board.

Let's start by creating the Board component. In your "src" folder, create a new file named "Board.js". In this file, import React and create a new function component named "Board". For now, this component will just return a div with the text "Board".

Copy
1
2
3
4
5
6
7
8
9
10
11
12
         import React from 'react';
        
        function Board() {
          return (
            <div>
              Board
            </div>
          );
        }
        
        export default Board;
       

‍

Creating the Square Component

Next, let's create the Square component. In your "src" folder, create a new file named "Square.js". In this file, import React and create a new function component named "Square". This component will return a button that represents a single cell on the board.

Copy
1
2
3
4
5
6
7
8
9
10
11
12
         import React from 'react';
        
        function Square() {
          return (
            <button className="square">
              {/* TODO */}
            </button>
          );
        }
        
        export default Square;
       

We'll add more functionality to this component later. For now, let's move on to the CSS.

‍

Styling the Game

Our game needs some styling to make it look like a real tic tac toe board. In your "src" folder, create a new CSS file named "index.css" and add the following code:

Copy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
         .board {
          display: grid;
          grid-template-columns: repeat(3, 1fr);
          gap: 10px;
        }
        
        .square {
          width: 60px;
          height: 60px;
          background-color: #fff;
          border: 1px solid #000;
          font-size: 24px;
          line-height: 60px;
          text-align: center;
        }
       

This CSS code styles the board as a grid with three columns, and styles each square as a 60x60 pixel button with a border and centered text.

‍

Adding Interactivity

Now that we have our components and styles set up, let's add some interactivity to our game. We'll start by adding state to our Board component. State is a feature of React that allows components to have their own mutable data that can change over time.

In the Board component, import the useState hook from React at the top of the file. Then, inside the Board function, declare a new state variable named "squares" and initialize it with an array of nine null values. This array represents the state of the game board, with each element corresponding to a square on the board.

Copy
1
2
3
4
5
6
7
8
9
         import React, { useState } from 'react';
    
        function Board() {
          const [squares, setSquares] = useState(Array(9).fill(null));
          // ...
        }
    
        export default Board;
       

Next, let's modify the Square component to display the value of its corresponding square on the board. To do this, pass the value as a prop from the Board component to the Square component, and then display this prop inside the button in the Square component.

Copy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
         import React, { useState } from 'react';
    
        function Board() {
          // ...
          return (
            <div>
              {squares.map((value, index) => (
                <Square key={index} value={value} />
              ))}
            </div>
          );
        }
    
        function Square({ value }) {
          return (
            <button className="square">
              {value}
            </button>
          );
        }
    
        export default Board;
       

Now, when you click on a square, it should display an "X" or an "O" depending on the current player. But we're not done yet. We still need to add logic to determine the winner of the game.

‍

Determining the Winner

To determine the winner of the game, we need to check if there are any winning combinations on the board. A winning combination is a row, column, or diagonal where all three squares have the same value.

In the Board component, create a new function named "calculateWinner" that takes the squares array as a parameter and returns the winner of the game, or null if there is no winner yet. This function should check all possible winning combinations and return the value of the winning squares if there is a winner.

Copy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
         import React, { useState } from 'react';
    
        function Board() {
          // ...
          function calculateWinner(squares) {
            const lines = [
              [0, 1, 2],
              [3, 4, 5],
              [6, 7, 8],
              [0, 3, 6],
              [1, 4, 7],
              [2, 5, 8],
              [0, 4, 8],
              [2, 4, 6],
            ];
            for (let i = 0; i < lines.length; i++) {
              const [a, b, c] = lines[i];
              if (squares[a] && squares[a] === squares[b] && squares[a] === squares[c]) {
                return squares[a];
              }
            }
            return null;
          }
          // ...
        }
    
        export default Board;
       

Now, you can use this function in the Board component to determine the winner of the game. If there is a winner, display a message at the top of the board announcing the winner. If there is no winner yet, display a message indicating whose turn it is.

Copy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
         import React, { useState } from 'react';
    
        function Board() {
          // ...
          const winner = calculateWinner(squares);
          let status;
          if (winner) {
            status = 'Winner: ' + winner;
          } else {
            status = 'Next player: ' + (xIsNext ? 'X' : 'O');
          }
          return (
            <div>
              <div>{status}</div>
              {/* ... */}
            </div>
          );
        }
    
        export default Board;
       

‍

Wrapping Up

Congratulations! You've just built a fully functional tic tac toe game with React. This project is a great introduction to React and web development, and it's a fun way to practice your skills.

If you want to take this project further, there are many ways you could enhance it. For example, you could add a feature to let players choose their own symbols, or a feature to let players play against the computer. The possibilities are endless!

As a software engineer, it's important to constantly learn and practice new skills. Building projects like this tic tac toe game is a great way to do that. I hope you found this guide helpful and that it inspired you to create your own projects.

Remember, the key to becoming a great developer is practice. So keep coding, keep learning, and most importantly, have fun!

If you want to see the full code for this project, you can find it on my GitHub page. If you have any questions or comments, feel free to leave them below. I'd love to hear from you!

And before I wrap up, I want to introduce you to a tool that has been a game-changer for me as a React developer. It's called WiseGPT . It's a promptless Generative AI for React developers that write code in your style without context limit. It also provides API integration by accepting Postman collection and also supports extending UI in the VSCode itself. It's like having a coding assistant that understands your coding style and helps you write better code faster. Check it out, it might just change the way you code!

Happy coding!