BUILD YOUR OWN GAME

Have you ever wondered if you could build your own chess game and play it with an AI engine on the browser? If you do, then you might...

BUILD YOUR OWN GAME
Written by TechnoLynx Published on 30 Jan 2023

It is no wonder that chess is the most popular intellectual game in the world. We can trace this game to the 6th century, which has stuck because of its complex and challenging nature until these days.

The first “chess machine” was invented by the Hungarian Wolfgang Von Kempelen (Kempelen Farkas) in 1770, known as the Mechanical Turk. The inventor claimed that the machine was fully automatic. Moreover, its elaborate mechanism and the fact that it had defeated even chess masters convinced many people. But did a successful chess machine already exist in the late 18th century? The answer is no. The truth was that Wolfgang von Kempelen had hired several chess masters and hid them inside the machine. The hidden players then controlled the mechanical arms of the Turk manually. As a result, the chess machine has traveled worldwide, impressed people everywhere, and inspired them to create their own.

In the last century, the concern became creating a machine with human-like intelligence. The mathematician and computer scientist Alan Turing was amongst the first to start laying down the principles of chess AI algorithms. Many are familiar with his name thanks to the recent movie “The Imitation Game,” about how he helped crack the German ciphers encoded with the Enigma machine [4]. However, his work on artificial intelligence led him toward chess, specifically the theory of using computers to play chess.

Around 1948, he and his colleague David Gawen Champerowne wrote the first computer chess program, called Turochamp, using the following basic principles that each piece on the board was assigned a value: pawn = 1, knight = 3, bishop = 3.5, rook = 5, queen = 10, and king = 1000. The algorithm foresaw two moves to calculate every possible combination of moves and then chose the most rewarding one. He tested his algorithm by challenging one of his friends, Alick Glennie. Since computers at the time were not up to heavy computing calculations, Turing calculated the moves on paper by hand (which took him more than 30 minutes on the average per move). Unfortunately, Turing and his algorithm lost the match. Nevertheless, he constructed the earliest known computer chess program.

So now, what about you? Are you ready to build your chessboard on a webpage?

Building the chessboard

In this section, we will teach you how to build a simple chessboard using html and javascript (no css styling needed). The method used may not be the best, yet it is easy to understand.

Let us break it into simple steps and statements:

a) Creating the canvas: to draw the chessboard, we brought a white canvas element in html with a specific height and width to stick the pieces on it later. The code in html is as simple as:





<canvas width=”512” height=”512” id=”canvas”></canvas>




b) Drawing the squares:

Since we have a white canvas, we chose to draw the squares and pieces using functions in JavaScript. The squares are created by slicing the canvas into 64 identical squares alternating between black and white. The code for this is as follows:

Note: dimension = 8 is the number of files/ ranks in the chessboard and the context.globalAlpha is set to 1 to make the canvas rendering fully opaque.



function draw_board()
{
    let square_colors = ["LightGray", "DarkGray"];
    context.globalAlpha = 1;

    for (let r = 0; r < dimension; ++r)
    {
        for (let c = 0; c < dimension; ++c)
        {
            context.fillStyle = square_colors[(r + c) % 2];
            context.fillRect(
                c * square_width,
                r * square_height,
                square_width,
                square_height);
        }
    }
}


c) Drawing the pieces:

The pieces are of a complex shape; therefore, images of them are easier to insert and use. You may get the images from any source and import them into your js code. Then we can organize them into a list to put them in a loop. You can see here that we used the instance game_state to place each piece in its correct initial position. Nevertheless, it is better explained later in the article.



function draw_pieces()
{
    context.globalAlpha = 1;

    for (let r = 0; r < dimension; ++r)
    {
        for (let c = 0; c < dimension; ++c)
        {
            let piece = game_state.board[r][c];
            let piece_image = images[piece];

            if (piece != "--")
            {
                context.drawImage(
                    piece_image, c * square_width, r * square_height);
            }
        }
    }
}


Now that we have all the drawing elements, how do we link them all together?

We link the html body with an initiating function that defines the canvas elements and events.

So in html, we add the following in the body tag:



body onload="window.index.init()"


Then in the js code:



export function init()
{
    canvas = document.getElementById("canvas");
    context = canvas.getContext("2d");
    square_width = canvas.width / 8;
    square_height = canvas.height / 8;
    for (let [name, image] of Object.entries(image_map))
    {
        images[name] = new Image(64, 64);
        images[name].onload = draw_pieces;
        images[name].src = image;
    }

    draw_board();
}


The view of our chessboard on the page after building the html
The view of our chessboard on the page after building the html

Basic functionality of a chess game

To create a real chess game, we must move the piece and keep track of their positions at all times. However, this is not as simple as it sounds in programming. Let’s say we want to create a class that defines the game and let’s call it game_state. It needs to state the initial board position and the offset of each piece and move it accordingly while logging the new board position. For example, this snippet code shows the board representation and then the knight offset.



export class Game_state
{
    constructor()
    {
        this.board =
        [
            ["bR", "bN", "bB", "bQ", "bK", "bB", "bN", "bR"],
            ["bP", "bP", "bP", "bP", "bP", "bP", "bP", "bP"],
            ["--", "--", "--", "--", "--", "--", "--", "--"],
            ["--", "--", "--", "--", "--", "--", "--", "--"],
            ["--", "--", "--", "--", "--", "--", "--", "--"],
            ["--", "--", "--", "--", "--", "--", "--", "--"],
            ["wP", "wP", "wP", "wP", "wP", "wP", "wP", "wP"],
            ["wR", "wN", "wB", "wQ", "wK", "wB", "wN", "wR"]
        ];
        this.knight_offsets =
        [
            [ 2,  1],
            [ 2, -1],
            [ 1,  2],
            [ 1, -2],
            [-1,  2],
            [-1, -2],
            [-2, -1],
            [-2,  1]
        ];
    }
}


Moving the pieces: There are different types of moves in chess. Any move could be a start, end, board move, capturing a piece, promotion move, en-passant move, or castle move. Each of them should be defined. For example, an en-passant move can be made with:



if (move.en_passant_move)
        {
            const direction = this.white_to_move ? 1 : -1;

            this.board[move.end[0] + direction][move.end[1]] = "--";
        }


By now, the piece could move, but what if the move was illegal?

Each move needs to be validated. If the move is illegal, then the piece should be retracted automatically. Yet, suppose you want to make it easier for the player to commit legal moves only. In that case, you can define all the valid moves of a piece and highlight them when the player touches (clicks on) any piece to move. For example, you may check all the possible moves of a piece with a code similar to this:



get_all_possible_moves()
    {
        let moves = [];

        for (let row = 0; row < this.board.length; ++row)
        {
            for (let column = 0; column < this.board[row].length; ++column)
            {
                let player = this.board[row][column][0];
                let current_color = this.white_to_move ? "w" : "b";

                if (player == current_color)
                {
                    let piece = this.board[row][column][1];

                    this.move_methods[piece].call(this, row, column, moves);
                }
            }
        }

        return moves;
    }


Did you make a move and regret it or make a mistake? Then you need to introduce the undo button to your game.

It is easily implemented in HTML by adding the following:

<div>
	<button onclick="window.index.undo_click()">Undo</button>
</div>

In js code, you may create the undo function as a method of the game_state, which allows you to edit other attributes in game-tracking, such as making a move and game-over status. Check it below:



export function undo_click()
{
    game_state.undo_move();
    made_move = true;
    game_over = false;

    refresh_state();
}


In concept, the undo method is purely popping the last move out of the log. Nevertheless, what if the move was a promotion or en-passant? Then we need to define more conditions that cover all possibilities. Let’s look at the code snippet below. It checks the move type as promotion and takes multiple actions to revoke it, including the return of the captured piece during the move.



if (last_move.promotion_move)
        {
            const color = this.white_to_move ? "b" : "w";

            this.board[last_move.end[0]][last_move.end[1]] =
                last_move.piece_captured;
            this.board[last_move.start[0]][last_move.start[1]] = color + 'P';
        }
		

Now we have all bases covered to start playing.

But do you want to play alone? Absolutely not. Let’s create an AI opponent.

The first thing that you need to build an AI opponent is data. Let’s put it as you feed the model some inputs to teach it how to digest them and generate the specific output. For chess, these data are recorded games between real players. These recorded games are formed as Portable Game Notation (PGN) files. Fortunately, many PGN databases are available online for free, and you may use any. Yet keep in your mind that these notation files need to be parsed. Our recommendation is to use chess.pgn in Python.

So let’s consider that you already have parsed the database and are ready to use it; thus, it’s time to build our AI model. We can create a sequential model out of multiple layers using TensorFlow and Keras. As you may see below, the model consists of 2 layers of 2D Convolutional Neural Networks (CNN), Flatten, 2 layers of Dense Neural Networks (DNN), and a softmax layer. You can notice that we used the Adam optimizer and binary loss entropy function to optimize the training process.



model = models.Sequential()
model.add(layers.Conv2D(filters=32, kernel_size=(3, 3), padding='same',
                        activation='relu', input_shape=(8, 8, 12)))
model.add(layers.Conv2D(filters=32, kernel_size=(5, 5), strides=(1, 1),
                        padding='valid', activation='relu'))
model.add(layers.Flatten())
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(2))
model.add(tf.keras.layers.Softmax())
model.summary()
model.compile(optimizer='adam',
              loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),
              metrics=['accuracy'])
			  

Note: after building the model and training it in Python, you can convert it into Javascript code.

After training the model, you need a function that will enable the AI engine to move a piece based on predicting the best valid move possible at a specific game state. In other words, you need to link the AI prediction with the chess functions provided earlier in the Javascript code. For example, selecting the best move will be as the following:



export function find_model_best_move(game_state, valid_moves)
{   let max_score = 0;
    let next_move = null;
    if (!model)
    {
        return next_move;
    }
    for (const move of valid_moves)
    {
        let scores;
        let score;
        // Make a valid move
        game_state.make_move(move);
        // Expand current position to 4D b/c model input requirement
        const input = tf.tensor([ game_state.get_position() ]);
        // Model predicts score (shape:(1,2)) of current position
        scores = model.predict(input).arraySync();
        console.assert(scores[0][0] + scores[0][1] >= 0.99);
        score = scores[0][game_state.white_to_move ? 0 : 1];
        if (score > max_score)
        {
            max_score = score;
            next_move = move;
        }
    }
    return next_move;
}


Don’t forget to add the button and link it with a function to enable the AI feature.

Are you wondering how to link all the files together? Well, module bundling is the solution to that.

Here we reach the end of this story. We provided tutorial-like instructions and discussion to build your own chess game on a webpage, define your desired rules, and program your ultimate opponent. Nevertheless, our description was brief in some points, but we hope our article encouraged you to go and search further.

What is your next move?

For the full code to build your own game, please check our repository on GitHub.

If you are interested in playing against our AI engine, please visit the page under Demos.

Cover image: by Felix Mittermeier on Unsplash

AI-Driven Opportunities for Smarter Problem Solving

AI-Driven Opportunities for Smarter Problem Solving

5/08/2025

AI-driven problem-solving opens new paths for complex issues. Learn how machine learning and real-time analysis enhance strategies.

10 Applications of Computer Vision in Autonomous Vehicles

10 Applications of Computer Vision in Autonomous Vehicles

4/08/2025

Learn 10 real world applications of computer vision in autonomous vehicles. Discover object detection, deep learning model use, safety features and real time video handling.

How AI Is Transforming Wall Street Fast

How AI Is Transforming Wall Street Fast

1/08/2025

Discover how artificial intelligence and natural language processing with large language models, deep learning, neural networks, and real-time data are reshaping trading, analysis, and decision support on Wall Street.

How AI Transforms Communication: Key Benefits in Action

How AI Transforms Communication: Key Benefits in Action

31/07/2025

How AI transforms communication: body language, eye contact, natural languages. Top benefits explained. TechnoLynx guides real‑time communication with large language models.

Top UX Design Principles for Augmented Reality Development

Top UX Design Principles for Augmented Reality Development

30/07/2025

Learn key augmented reality UX design principles to improve visual design, interaction design, and user experience in AR apps and mobile experiences.

AI Meets Operations Research in Data Analytics

AI Meets Operations Research in Data Analytics

29/07/2025

AI in operations research blends data analytics and computer science to solve problems in supply chain, logistics, and optimisation for smarter, efficient systems.

Generative AI Security Risks and Best Practice Measures

Generative AI Security Risks and Best Practice Measures

28/07/2025

Generative AI security risks explained by TechnoLynx. Covers generative AI model vulnerabilities, mitigation steps, mitigation & best practices, training data risks, customer service use, learned models, and how to secure generative AI tools.

Best Lightweight Vision Models for Real‑World Use

Best Lightweight Vision Models for Real‑World Use

25/07/2025

Discover efficient lightweight computer vision models that balance speed and accuracy for object detection, inventory management, optical character recognition and autonomous vehicles.

Image Recognition: Definition, Algorithms & Uses

Image Recognition: Definition, Algorithms & Uses

24/07/2025

Discover how AI-powered image recognition works, from training data and algorithms to real-world uses in medical imaging, facial recognition, and computer vision applications.

AI in Cloud Computing: Boosting Power and Security

AI in Cloud Computing: Boosting Power and Security

23/07/2025

Discover how artificial intelligence boosts cloud computing while cutting costs and improving cloud security on platforms.

 AI, AR, and Computer Vision in Real Life

AI, AR, and Computer Vision in Real Life

22/07/2025

Learn how computer vision, AI, and AR work together in real-world applications, from assembly lines to social media, using deep learning and object detection.

Real-Time Computer Vision for Live Streaming

Real-Time Computer Vision for Live Streaming

21/07/2025

Understand how real-time computer vision transforms live streaming through object detection, OCR, deep learning models, and fast image processing.

3D Visual Computing in Modern Tech Systems

18/07/2025

Understand how 3D visual computing, 3D printing, and virtual reality transform digital experiences using real-time rendering, computer graphics, and realistic 3D models.

Creating AR Experiences with Computer Vision

17/07/2025

Learn how computer vision and AR combine through deep learning models, image processing, and AI to create real-world applications with real-time video.

Machine Learning and AI in Communication Systems

16/07/2025

Learn how AI and machine learning improve communication. From facial expressions to social media, discover practical applications in modern networks.

The Role of Visual Evidence in Aviation Compliance

15/07/2025

Learn how visual evidence supports audit trails in aviation. Ensure compliance across operations in the United States and stay ahead of aviation standards.

GDPR-Compliant Video Surveillance: Best Practices Today

14/07/2025

Learn best practices for GDPR-compliant video surveillance. Ensure personal data safety, meet EU rules, and protect your video security system.

Next-Gen Chatbots for Immersive Customer Interaction

11/07/2025

Learn how chatbots and immersive portals enhance customer interaction and customer experience in real time across multiple channels for better support.

Real-Time Edge Processing with GPU Acceleration

10/07/2025

Learn how GPU acceleration and mobile hardware enable real-time processing in edge devices, boosting AI and graphics performance at the edge.

AI Visual Computing Simplifies Airworthiness Certification

9/07/2025

Learn how visual computing and AI streamline airworthiness certification. Understand type design, production certificate, and condition for safe flight for airworthy aircraft.

Real-Time Data Analytics for Smarter Flight Paths

8/07/2025

See how real-time data analytics is improving flight paths, reducing emissions, and enhancing data-driven aviation decisions with video conferencing support.

AI-Powered Compliance for Aviation Standards

7/07/2025

Discover how AI streamlines automated aviation compliance with EASA, FAA, and GDPR standards—ensuring data protection, integrity, confidentiality, and aviation data privacy in the EU and United States.

AI Anomaly Detection for RF in Emergency Response

4/07/2025

Learn how AI-driven anomaly detection secures RF communications for real-time emergency response. Discover deep learning, time series data, RF anomaly detection, and satellite communications.

AI-Powered Video Surveillance for Incident Detection

3/07/2025

Learn how AI-powered video surveillance with incident detection, real-time alerts, high-resolution footage, GDPR-compliant CCTV, and cloud storage is reshaping security.

Artificial Intelligence on Air Traffic Control

24/06/2025

Learn how artificial intelligence improves air traffic control with neural network decision support, deep learning, and real-time data processing for safer skies.

5 Ways AI Helps Fuel Efficiency in Aviation

11/06/2025

Learn how AI improves fuel efficiency in aviation. From reducing fuel use to lowering emissions, see 5 real-world use cases helping the industry.

AI in Aviation: Boosting Flight Safety Standards

10/06/2025

Learn how AI is helping improve aviation safety. See how airlines in the United States use AI to monitor flights, predict problems, and support pilots.

IoT Cybersecurity: Safeguarding against Cyber Threats

6/06/2025

Explore how IoT cybersecurity fortifies defences against threats in smart devices, supply chains, and industrial systems using AI and cloud computing.

Large Language Models Transforming Telecommunications

5/06/2025

Discover how large language models are enhancing telecommunications through natural language processing, neural networks, and transformer models.

Real-Time AI and Streaming Data in Telecom

4/06/2025

Discover how real-time AI and streaming data are transforming the telecommunications industry, enabling smarter networks, improved services, and efficient operations.

AI in Aviation Maintenance: Smarter Skies Ahead

3/06/2025

Learn how AI is transforming aviation maintenance. From routine checks to predictive fixes, see how AI supports all types of maintenance activities.

AI-Powered Computer Vision Enhances Airport Safety

2/06/2025

Learn how AI-powered computer vision improves airport safety through object detection, tracking, and real-time analysis, ensuring secure and efficient operations.

Fundamentals of Computer Vision: A Beginner's Guide

30/05/2025

Learn the basics of computer vision, including object detection, convolutional neural networks, and real-time video analysis, and how they apply to real-world problems.

Computer Vision in Smart Video Surveillance powered by AI

29/05/2025

Learn how AI and computer vision improve video surveillance with object detection, real-time tracking, and remote access for enhanced security.

Generative AI Tools in Modern Video Game Creation

28/05/2025

Learn how generative AI, machine learning models, and neural networks transform content creation in video game development through real-time image generation, fine-tuning, and large language models.

Artificial Intelligence in Supply Chain Management

27/05/2025

Learn how artificial intelligence transforms supply chain management with real-time insights, cost reduction, and improved customer service.

Content-based image retrieval with Computer Vision

26/05/2025

Learn how content-based image retrieval uses computer vision, deep learning models, and feature extraction to find similar images in vast digital collections.

What is Feature Extraction for Computer Vision?

23/05/2025

Discover how feature extraction and image processing power computer vision tasks—from medical imaging and driving cars to social media filters and object tracking.

Machine Vision vs Computer Vision: Key Differences

22/05/2025

Learn the differences between machine vision and computer vision—hardware, software, and applications in automation, autonomous vehicles, and more.

Computer Vision in Self-Driving Cars: Key Applications

21/05/2025

Discover how computer vision and deep learning power self-driving cars—object detection, tracking, traffic sign recognition, and more.

Machine Learning and AI in Modern Computer Science

20/05/2025

Discover how computer science drives artificial intelligence and machine learning—from neural networks to NLP, computer vision, and real-world applications. Learn how TechnoLynx can guide your AI journey.

Real-Time Data Streaming with AI

19/05/2025

You have surely heard that ‘Information is the most powerful weapon’. However, is a weapon really that powerful if it does not arrive on time? Explore how real-time streaming powers Generative AI across industries, from live image generation to fraud detection.

Core Computer Vision Algorithms and Their Uses

17/05/2025

Discover the main computer vision algorithms that power autonomous vehicles, medical imaging, and real-time video. Learn how convolutional neural networks and OCR shape modern AI.

Applying Machine Learning in Computer Vision Systems

14/05/2025

Learn how machine learning transforms computer vision—from object detection and medical imaging to autonomous vehicles and image recognition.

Cutting-Edge Marketing with Generative AI Tools

13/05/2025

Learn how generative AI transforms marketing strategies—from text-based content and image generation to social media and SEO. Boost your bottom line with TechnoLynx expertise.

AI Object Tracking Solutions: Intelligent Automation

12/05/2025

AI tracking solutions are incorporating industries in different sectors in safety, autonomous detection and sorting processes. The use of computer vision and high-end computing is key in AI tracking.

Feature Extraction and Image Processing for Computer Vision

9/05/2025

Learn how feature extraction and image processing enhance computer vision. Discover techniques, applications, and how TechnoLynx can assist your AI projects.

Fine-Tuning Generative AI Models for Better Performance

8/05/2025

Understand how fine-tuning improves generative AI. From large language models to neural networks, TechnoLynx offers advanced solutions for real-world AI applications.

← Back to Blog Overview