After developing the online game and server, plus being now able to send the game data to the ESP32 (the brain of the chessboard), the next step is to design and build the physical chessboard.

After many brainstorming sessions, we settled for this design of the chessboard:

Key Elements of the Design:

• Sphere : 20 cm diameter, tilted at approximately 25°, will be 3d printed.
• Chess Piece : 60 mm in height, held in place with magnets, will also be 3d printed.
• Rail : The rail will be made of mutiple layer of laser cutted wood/acrylic.
• Motors and Actuators:
  • 3 stepper motors (sphere rotation, capture zone rotation, cart movement on the rail).
  • 1 linear actuator.
  • 2 servos (one for linear actuator rotation, one for the gripper).
• User Interface: A small screen for displaying information and configuring the chessboard.

How It Works:

Each square on the spherical chessboard is accessible through two movements (if we visualize the sphere as a flat plane) : rotating the sphere move through the files and moving along the circular rail move trought the ranks . 

This is how a move should be executed :

1. Moving to the targeted piece: The cart moves along the rail and/or the sphere rotates to align the gripper actuator with the targeted piece position.
2. Taking the Piece: The linear actuator extends, the gripper close to grab the chess piece then the actuator retract.
3. Moving to the target square: The cart moves along the rail and/or the sphere rotates to align the gripper with the desired position.
4. Releasing the Piece: The linear actuator extends, and the gripper open toreleases the piece.

And this is how capture should be handled  :

The cart moves to a fixed position above the capture zone (a rotating circle at the bottom). The linear actuator rotates, extends, and places the piece in the capture zone. The zone then rotates to make space for the next to be captured piece.

Since the goal of the project is to allow people from different parts of the country to play against each other on their devices and on separate spherical chessboards, we needed to design a server-client infrastructure where the server relays requests between clients—the clients being both the game and the ESP32 microcontroller.

After analyzing how all the components (game, server, ESP32) should interact, we created a diagram to illustrate how communication will take place.

Our system is built around a server-client architecture using WebSockets.
It consists of three main components:

1. Game Clients (The player on the web chess game) – The players interact with the game through their web browsers, they can send move requests and receive game updates from the server.

2. Server (Python WebSocket server) – It manages all game sessions, player connections, and communication between devices. It validates moves, relays commands, and synchronizes thegame.

3. ESP32 (The Robotic Chessboard) – The microcontroller of the chessboard controls the robotic arm and executes chess moves on the physical spherical chessboard based on commands received from the server.

How It Works

• Player Connection: Players connect to a chessboard using an ORB code, which links them to a specific chessboard. If a game is already in progress on this chessboard, the player can continue it or end it, otherwise if not game were in progress they can start a new game.

• Move Execution:

  1. A player makes a move in the game.
  2. A move request is sent to the server.
  3. The server checks if the chessboard is ready to execute a move, if yes it then check is the move request received is a valid move. 
  4. If the move is valid, it is sent back to all player in the game, then it is sent to the chessboard where the move is executed.

After implementing this Infrastructure (4000+ lines of code), we had a fully functional online game, with data being sent between the game, server, and ESP32 in real time.

Code of the game can be found here : Github link

Code of the server can be found here : Github link

Code of the esp32 can be found here : Github link

For our project, since we are playing on a spherical chessboard, the rules of chess are not the same as in classical chess. A variant of chess will be played. Given the spherical nature of the board, we had the choice between two variants: 
Spherical chess (link), which fully utilizes the unique properties of the chessboard.

Cylinder chess (link), which is typically played on a cylindrical board but can also be adapted to a spherical one.

After researching both variants, we decided to settle on cylinder chess for two main reasons. First, it is much less confusing and easier for players to understand. Second, since we will be coding our chess game from scratch, implementing cylinder chess is significantly simpler. It is essentially standard chess but without the horizontal "walls," allowing pieces to wrap around the board horizontally.

As mentioned, we will be developing the game from scratch for two reasons:

1. We couldn't find any good open-source examples that fit our needs.
2. Since the game must be playable online, designing the code from the ground up will allow us to easily integrate the networking functionality later.

The game will be developed using GameMaker Studio, as we are already very comfortable with the software. It also provides solid networking capabilities and supports HTML export, which is essential for making the game playable in a web browser.

Making the game was pretty straightforward; it was essentially like coding a normal chess game, except that whenever a position exceeded the chessboard limits, it would wrap around to the other side. In GameMaker, we implemented it like this:

And as a said the rest was just coding a normal chess game, this was the final result :

(Chess Set - Pixel Art)

The next step was to implement networking into the game.

The goal of this project is to create a spherical chessboard where moves are played by a small robotic arm moving along a circular track.

The robotic arm will execute the moves made by players in an online chess game.

Here is a rough draft of our vision for the final product :

Our broader vision is to build multiple chessboards across different campuses of our school, allowing players to compete remotely. Each robotic arm will replicate the moves made by players in real-time on their respective boards.

Our main inspiration is the OrbChess by NKD Puzzle: OrbChess – NKD Puzzle.

We will first focus on the software aspects of the project—the chess game, game server, networking, etc.—before moving on to the hardware.

For the implementation:

• We'll use an ESP32-DevKitC-32E as the brain of the chessboard.
• GameMaker Studio will be used to develop the chess game.
• The game server will be built with Python using WebSockets for real-time communication.

This project is ambitious as it covers IoT, mechanical design, game development, and networking.