Learn how to build a multiplayer chess game with React

In this tutorial, we will guide you through building a multiplayer chess game using the SuperViz. Multiplayer games require real-time synchronization and interaction between players, making them ideal applications for SuperViz's capabilities. This tutorial will show you how to create a chess game where two players can play against each other in real-time, seeing each other's moves as they happen.

We'll demonstrate how to set up a chessboard using the react-chessboard library, manage the game state with chess.js, and synchronize player moves with SuperViz. This setup allows multiple participants to join a chess game, make moves, and experience a seamless and interactive chess game environment. Let's get started!

Step 1: Set Up Your React Application

To begin, you'll need to set up a new React project where we will integrate SuperViz.

1. Create a New React Project

First, create a new React application using Create React App with TypeScript.

1
npm create vite@latest chess-game -- --template react-ts
2
cd chess-game

2. Install Required Libraries

Next, install the necessary libraries for our project:

1
npm install @superviz/sdk react-chessboard chess.js uuid

• @superviz/sdk: SDK for integrating real-time collaboration features, including synchronization.
• react-chessboard: A library for rendering a chessboard in React applications.
• chess.js: A library for managing chess game logic and rules.
• uuid: A library for generating unique identifiers, useful for creating unique participant IDs.

3. Configure tailwind

In this tutorial, we'll use the Tailwind css framework. First, install the tailwind package.

1
npm install -D tailwindcss postcss autoprefixer
2
npx tailwindcss init -p

We then need to configure the template path. Open tailwind.config.js in the root of the project and insert the following code.

1
/** @type {import('tailwindcss').Config} */
2
export default {
3
content: [
4
"./index.html",
5
"./src/**/*.{js,ts,jsx,tsx}",
6
],
7
theme: {
8
extend: {},
9
},
10
plugins: [],
11
}

Then we need to add the tailwind directives to the global CSS file. (src/index.css)

1
@tailwind base;
2
@tailwind components;
3
@tailwind utilities;

4. Set Up Environment Variables

Create a .env file in your project root and add your SuperViz developer key. This key will be used to authenticate your application with SuperViz services.

1
VITE_SUPERVIZ_API_KEY=YOUR_SUPERVIZ_DEVELOPER_KEY

Step 2: Implement the Main Application

In this step, we'll implement the main application logic to initialize SuperViz and handle real-time chess moves.

1. Implement the App Component

Open src/App.tsx and set up the main application component using SuperViz to manage the collaborative environment.

1
import { v4 as generateId } from 'uuid';
2
import { useCallback, useEffect, useRef, useState } from "react";
3
import SuperVizRoom, { Realtime, RealtimeComponentEvent, RealtimeMessage, WhoIsOnline } from '@superviz/sdk';
4
import { Chessboard } from "react-chessboard";
5
import { Chess, Square } from 'chess.js';

Explanation:

• Imports: Import necessary components from React, SuperViz SDK, react-chessboard, chess.js, and UUID for managing state, initializing SuperViz, rendering the chessboard, and generating unique identifiers.

2. Define Constants

Define constants for the API key, room ID, and player ID.

1
const apiKey = import.meta.env.VITE_SUPERVIZ_API_KEY as string;
2
const ROOM_ID = 'chess-game';
3
const PLAYER_ID = generateId();

Explanation:

• apiKey: Retrieves the SuperViz API key from environment variables.
• ROOM_ID: Defines the room ID for the SuperViz session.
• PLAYER_ID: Generates a unique player ID using the uuid library.

3. Define Chess Message Type

Create a type for handling chess move messages.

1
type ChessMessageUpdate = RealtimeMessage & {
2
  data: {
3
    sourceSquare: Square;
4
    targetSquare: Square;
5
  };
6
};

Explanation:

• ChessMessageUpdate: Extends the RealtimeMessage to include the source and target squares for a chess move.

4. Create the App Component

Set up the main App component and initialize state variables.

1
export default function App() {
2
  const [initialized, setInitialized] = useState(false);
3
  const [gameState, setGameState] = useState<Chess>(new Chess());
4
  const [gameFen, setGameFen] = useState<string>(gameState.fen());
5

6
  const channel = useRef<any | null>(null);

Explanation:

• initialized: A state variable to track whether the SuperViz environment has been set up.
• gameState: A state variable to manage the chess game state using the chess.js library.
• gameFen: A state variable to store the FEN (Forsyth-Edwards Notation) string representing the current game position.
• channel: A ref to store the real-time communication channel.

5. Initialize SuperViz and Real-Time Components

Create an initialize function to set up the SuperViz environment and configure real-time synchronization.

1
const initialize = useCallback(async () => {
2
  if (initialized) return;
3

4
  const superviz = await SuperVizRoom(apiKey, {
5
    roomId: ROOM_ID,
6
    participant: {
7
      id: PLAYER_ID,
8
      name: 'player-name',
9
    },
10
    group: {
11
      id: 'chess-game',
12
      name: 'chess-game',
13
    }
14
  });
15

16
  const realtime = new Realtime();
17
  const whoIsOnline = new WhoIsOnline();
18

19
  superviz.addComponent(realtime);
20
  superviz.addComponent(whoIsOnline);
21

22
  setInitialized(true);
23

24
  realtime.subscribe(RealtimeComponentEvent.REALTIME_STATE_CHANGED, () => {
25
    channel.current = realtime.connect('move-topic');
26

27
    channel.current.subscribe('new-move', handleRealtimeMessage);
28
  });
29
}, [handleRealtimeMessage, initialized]);

Explanation:

• initialize: An asynchronous function that initializes the SuperViz room and checks if it's already initialized to prevent duplicate setups.
• SuperVizRoom: Configures the room, participant, and group details for the session.
• Realtime Subscription: Connects to the move-topic channel and listens for new moves, updating the local state accordingly.

6. Handle Chess Moves

Create a function to handle chess moves and update the game state.

1
const makeMove = useCallback((sourceSquare: Square, targetSquare: Square) => {
2
  try {
3
    const gameCopy = gameState;
4
    gameCopy.move({ from: sourceSquare, to: targetSquare, promotion: 'q' });
5

6
    setGameState(gameCopy);
7
    setGameFen(gameCopy.fen());
8

9
    return true;
10
  } catch (error) {
11
    console.log('Invalid Move', error);
12
    return false;
13
  }
14
}, [gameState]);

Explanation:

• makeMove: Attempts to make a move on the chessboard, updating the game state and FEN string if the move is valid.
• Promotion: Automatically promotes a pawn to a queen if it reaches the last rank.

7. Handle Piece Drop

Create a function to handle piece drop events on the chessboard.

1
const onPieceDrop = (sourceSquare: Square, targetSquare: Square) => {
2
  const result = makeMove(sourceSquare, targetSquare);
3

4
  if (result) {
5
    channel.current.publish('new-move', {
6
      sourceSquare,
7
      targetSquare,
8
    });
9
  }
10

11
  return result;
12
};

Explanation:

• onPieceDrop: Handles the logic for when a piece is dropped on a new square, making the move and publishing it to the SuperViz channel if valid.

8. Handle Real-Time Messages

Create a function to handle incoming real-time messages for moves made by other players.

1
const handleRealtimeMessage = useCallback((message: ChessMessageUpdate) => {
2
  if (message.participantId === PLAYER_ID) return;
3

4
  const { sourceSquare, targetSquare } = message.data;
5
  makeMove(sourceSquare, targetSquare);
6
}, [makeMove]);

Explanation:

• handleRealtimeMessage: Listens for incoming move messages and updates the game state if the move was made by another participant.

9. Use Effect Hook for Initialization

Use the useEffect hook to trigger the initialize function on component mount.

1
useEffect(() => {
2
  initialize();
3
}, [initialize]);

Explanation:

• useEffect: Calls the initialize function once when the component mounts, setting up the SuperViz environment and real-time synchronization.

10. Render the Application

Return the JSX structure for rendering the application, including the chessboard and collaboration features.

1
return (
2
  <div className='w-full h-full bg-gray-200 flex items-center justify-center flex-col'>
3
    <header className='w-full p-5 bg-purple-400 flex items-center justify-between'>
4
      <h1 className='text-white text-2xl font-bold'>SuperViz Chess Game</h1>
5
    </header>
6
    <main className='w-full h-full flex items-center justify-center'>
7
      <div className='w-[500px] h-[500px] shadow-sm border-2 border-gray-300 rounded-md'>
8
        <Chessboard position={gameFen} onPieceDrop={onPieceDrop} />
9
        <div className='w-[500px] h-[50px] bg-gray-300 flex items-center justify-center'>
10
          <p className='text-gray-800 text-2xl font-bold'>Turn: {gameState.turn() === 'b' ? 'Black' : 'White'}</p>
11
        </div>
12
      </div>
13
    </main>
14
  </div>
15
);

Explanation:

• Header: Displays the title of the application.
• Chessboard: Renders the chessboard using the Chessboard component, with gameFen as the position and onPieceDrop as the event handler for piece drops.
• Turn Indicator: Displays the current player's turn (Black or White).

Step 3: Understanding the Project Structure

Here's a quick overview of how the project structure supports a multiplayer chess game:

1. App.tsx
   • Initializes the SuperViz environment.
   • Sets up participant information and room details.
   • Handles real-time synchronization for chess moves.
2. Chessboard
   • Displays the chessboard and manages piece movements.
   • Integrates real-time communication to synchronize moves between players.
3. Chess Logic
   • Uses chess.js to manage game rules and validate moves.
   • Updates the game state and FEN string to reflect the current board position.

Step 4: Running the Application

1. Start the React Application

To run your application, use the following command in your project directory:

1
npm run dev

This command will start the development server and open your application in the default web browser. You can interact with the chessboard and see moves in real-time as other participants join the session.

2. Test the Application

• Real-Time Chess Moves: Open the application in multiple browser windows or tabs to simulate multiple participants and verify that moves made by one player are reflected in real-time for others.
• Collaborative Interaction: Test the responsiveness of the application by making moves and observing how the game state updates for all participants.

Summary

In this tutorial, we built a multiplayer chess game using SuperViz for real-time synchronization. We configured a React application to handle chess moves, enabling multiple players to collaborate seamlessly on a shared chessboard. This setup can be extended and customized to fit various scenarios where game interaction is required.

Feel free to explore the full code and further examples in the GitHub repository for more details.