What most don’t realize is that the real engine behind this AI revolution started in a place few expected: inside the humble gaming PC.

The same graphics cards once built to render smooth 3D visuals are now powering chatbots, image generators, and self-driving systems. The journey from pixels to predictions is one of the most fascinating stories in modern computing.

The CPU Era and Its Limits

In the early days of machine learning, researchers depended on CPUs to crunch data.

CPUs were versatile and great for handling a wide range of tasks, but they had one big limitation: they worked on problems in sequence.

That means they could process only a few operations at a time. For small models, this was fine. But as neural networks grew in complexity, training them on CPUs became painfully slow.

Imagine trying to teach a computer to recognize images. A neural network might have millions of parameters, and every single one needs to be adjusted again and again during training.

On CPUs, that could take days or even weeks. Researchers quickly realized that if AI was going to advance, it needed a completely different kind of hardware.

How GPUs Entered the Picture

Graphics processing units, or GPUs, were originally built to render the fast-moving images in video games. They were designed for parallelism, performing thousands of small calculations at the same time.

While a CPU might have a handful of cores, a GPU has thousands. This architecture made GPUs ideal for the kind of math used in machine learning, where the same operation needs to be applied to huge amounts of data simultaneously.

In a way, the GPU was built for games but destined for AI. What started as a chip to make lighting effects smoother and explosions look more realistic soon found a second life powering neural networks.

Around the early 2010s, researchers began experimenting with running deep learning algorithms on GPUs, and the results were stunning. Training times dropped from weeks to days, and accuracy improved.

It was a quiet revolution happening in research labs around the world.

The Role of Gaming PCs in Early AI Research

Here’s where the story gets even more interesting: many of the early breakthroughs in AI didn’t come from massive data centres or expensive supercomputers. They came from researchers using consumer-grade GPUs, often sitting inside regular gaming PCs.

These machines, built for entertainment, turned out to be powerful enough for deep learning experiments.

NVIDIA’s CUDA platform made this possible by allowing developers to program GPUs for tasks beyond graphics. Suddenly, a gaming GPU could handle complex scientific computations.

Researchers used their own rigs, sometimes the same computers they played games on at night, to train neural networks that recognized speech, images, and text. The gaming PC became a testbed for the future of artificial intelligence.

The Turning Point: AlexNet and the Deep Learning Boom

In 2012, a neural network called AlexNet stunned the world by winning the ImageNet competition, a major benchmark in computer vision.

What made AlexNet special wasn’t just its architecture but the hardware behind it. It ran on two NVIDIA GTX 580 GPUs, hardware you could buy for your low-cost gaming PC. That win marked a turning point. It proved that GPUs weren’t just for rendering graphics – they were the key to advancing AI.

After that, the AI world changed fast. Every major research lab and tech company started building GPU clusters. NVIDIA, sensing the opportunity, leaned into AI hardware development.

The same company that once catered mainly to gamers now powered Google, OpenAI, and Tesla. What started as a tool for better visuals had become the backbone of machine intelligence.

Why GPUs Are So Good at AI

GPUs excel at matrix math, the kind of computation that neural networks rely on.

When you train a model, you’re constantly multiplying and adding matrices of numbers. GPUs do this faster because they handle thousands of operations in parallel. They’re also designed with high memory bandwidth, meaning they can move large amounts of data in and out quickly.

This architecture fits perfectly with deep learning workloads. Whether it’s image recognition or language translation, GPUs can process huge batches of data at once.

CPUs, by contrast, get bottlenecked by sequential processing. The difference in performance is like comparing a single craftsman building a house to a team of thousands working at once.

The AI Hardware Race

As AI took off, the demand for GPUs exploded. What began in gaming PCs scaled up into massive data centers filled with thousands of cards.

Companies like NVIDIA developed new lines of GPUs specifically for AI, such as the Tesla and A100 series. Other players joined the race too, like AMD with its ROCm platform, and Google with its custom TPUs (Tensor Processing Units).

Yet, even today, the line between gaming and AI hardware remains blurred. The same RTX GPUs designed for gamers are still used by many AI researchers and small startups.

A powerful gaming PC equipped with a modern GPU can run local AI models, generate images, or even fine-tune small language models. The hardware that made virtual worlds come alive now brings intelligence to our real one.

The Future of GPUs and AI

As AI models grow larger, new challenges are emerging. GPUs are evolving to handle trillion-parameter models, but they’re also getting smarter about energy use and efficiency.

Technologies like chiplet design, optical interconnects, and AI-specific cores are pushing performance further while keeping costs down.

Meanwhile, local AI is making a comeback. With advancements in GPU efficiency, many users are experimenting with running models on their own machines.

A well-equipped gaming PC can now do what once required access to a cloud GPU cluster. This shift could democratize AI development, letting anyone with the right hardware explore the field from home.

Conclusion

The GPU’s journey from gaming to AI is one of the most unexpected transformations in tech history. What started as a chip to render virtual landscapes evolved into the heart of artificial intelligence. From early experiments on gaming PCs to the data centers powering today’s largest models, GPUs have bridged the worlds of creativity, computation, and cognition.

As we look ahead, it’s clear that the same technology that once made games more realistic is now making machines more intelligent. The story of the GPU reminds us that innovation often comes from unexpected places, and sometimes, the future of AI begins in the glow of a gaming screen.

Hope you enjoyed this article. Find me on Linkedin or visit my website.

In this tutorial we will learn about the Minimax algorithm. It is a backtracking algorithm that is used in decision making and game theory. It finds the optimal move for a player, assuming their opponent also plays optimally. It is widely used in two-player turn-based games.

You will learn how to create your own AI that plays any of the games mentioned above or any other similar games. Also, to make this as comprehensible as possible, I will be applying the algorithm to a Tic-Tac-Toe game.

We will not cover the whole process of creating the game, but only the part related to AI since this is our topic. If you're interested in the game-creating process, you can check out this Tic-Tac-Toe game that uses AI and its source code on GitHub. It's a project that I built long ago but it's still one of my favorites.

Table of contents

• How the minimax algorithm works
• Limitations of the minimax algorithm
• How to improve the time complexity of the algorithm
• Tic-Tac-Toe AI Code
• Conclusion

How the Minimax Algorithm Works

The minimax algorithm's methodology is quite simple. First, it checks all the possible combinations from a given position. Then it chooses the best possible move that maximizes the chances of winning, assuming that both players play perfectly.

To illustrate this, let’s consider a Tic-Tac-Toe game to make this more convincing. As you might know, in this game there are 2 players and 9 available slots. So we can represent a game by using an array of length 9.

Now let's take this board as an example: as you can see, a game board is an array of length 9 whose values can be either X, O, or an empty string. An empty string means this position is still available.

Board array to game board

Now it's X's turn. The minimax algorithm will try all the game combinations from this position. Then it'll try all the game combinations from the resulting child positions until reaching a position where the game ends by either X winning, O winning, or a draw (which occurs when the board is full and no one is winning).

This picture illustrates how this works:

All game combinations demo

We can achieve this using recursion. I will show the code at the end, but for now, let's focus on understanding how we can process the game combinations to get the optimal move. We will consider these cases:

• The board which has a winning position for X is valued by 1 point
• The board which has a winning position for O is valued by -1 point
• The board where the position is a draw has 0 points

If we're finding the optimal move for X, we should find the board with the most points. But what if a board isn't finished yet? Then we should choose a board depending on its child boards – but which do we choose?

I need you to focus on this part, as it's the most important part. When I introduced the algorithm I said that it finds all the game combinations assuming both players are playing optimally.

After the first generation of child boards, it will be O's turn. With the assumption that O is playing optimally, we should choose a board where O is doing his best that is one of the boards with the fewest points (since when O wins, the board returns -1).

Why are we choosing like this? Imagine if we pick the maximum value when it's O's turn, then we're letting X win. This makes the algorithm useless, since we need to assume O plays optimally.

For the 3rd generation, the player is X again and we will choose the board with the most points once more.

This alternating method of choosing the maximum and the minimum values is the reason why this algorithm is called the Minimax algorithm. Check out this visualization for further clarification:

Minimax mechanism

This is the same example given above. The 2 boards at the bottom are winning for X, so each will return a value of 1. Here, it’s X’s turn so we will pick the optimal value - it happens that both boards have a value of 1 here.

As I said earlier, if a board doesn't satisfy winning or drawing conditions, we will look at its child boards. That's why the parents of the boards with value 1 will have a value of 1.

Minimax algorithm mechanism

Here it's O's turn so we will pick the lowest possible value which happens to be 1. I've chosen this specific example to make things simple, but this works on all boards.

Minimax mechanism

Finally it's X's turn again and we will maximize the value of the chosen board. That’s why we can choose the child board on the left or the one on the right or the one in the middle – it doesn’t matter since their values are the same.

In the end, the optimal move for X to maximize its winning chances is in positions 7, 8 or 9. If you're still not convinced, take any board combination and draw the combination tree and you'll get a satisfying result - I strongly recommend drawing this on paper.

Limitations of the Minimax Algorithm

As you've seen, the algorithm is recursive and the number of executions may become huge.

For example, for a Tic-Tac-Toe game the number of executions is approximately “9!”(9 factorial). The reason why is for the first move there are 9 possibilities and then for each subsequent move there are 8 and so on.

That's not a problem for tic-tac-toe, but consider a chess game. If we were to write the number of combinations, the entire universe would not be enough. So the minimax is often used as part of an engine but it’s not enough to fulfill our needs.

How to Improve the Time Complexity of the Algorithm

You may have noticed that using this approach may result in some repetitive boards and that we need to compute their value multiple times. So why not store the value of every board when calculated?

So now, for every iteration, we will check if a position has already occurred. If so, we will use its stored value. Else, we can compute the value of the position and then store it.

For storing values, we will use a dictionary which allows searching in O(1). Using this approach we can reduce the time complexity – but still, it wouldn't be efficient in some cases.

I’ve built a Connect 4 game with this algorithm and it was horrible in terms of runtime. So, instead of looking for all the combinations, I stopped at a certain depth which led to an AI that can see n moves ahead.

If you're interested, check out this GitHub repository for the Connect 4 game code. I wrote it a long time ago but it's cool to see.

Tic-Tac-Toe AI Code

Now let's implement some helper functions first. We will first check if there are 3 horizontal, vertical, or diagonal non-empty string values in the board array.

// Board array
let xo=['','','',
        '','','',
        '','','']

// Writing this function we need to make sure the equal values are not empty strings

// Before this I will write a helper function to make sure 3 indexes have no empty strings

function helper(index1,index2,index3){
  return xo[index1] !='' && xo[index2] !='' && xo[index3]!=''
}



function checkwin(){

   return (xo[0]==xo[1] && xo[1] ==xo[2] && helper(0,1,2)) ||
          (xo[3]==xo[4] && xo[4] ==xo[5] && helper(3,4,5)) ||
          (xo[6]==xo[7] && xo[7] ==xo[8] && helper(6,7,8)) ||
          (xo[0]==xo[3] && xo[3] ==xo[6] && helper(0,3,6)) ||
          (xo[1]==xo[4] && xo[4] ==xo[7] && helper(1,4,7)) || 
          (xo[2]==xo[5] && xo[5] ==xo[8] && helper(2,5,8)) ||
          (xo[0]==xo[4] && xo[4] ==xo[8] && helper(0,4,8)) ||
          (xo[2]==xo[4] && xo[4] ==xo[6] && helper(2,4,6))

}

//And finally a function to check if there is a draw which will check if all board values are not empty strings. This only works after checking that there is no winning conditions first

function boardfull(){
  return xo.every((elem)=>{
   return elem !=''
  })
}

Now we have the function to check if a winning state is there and we can finally write the Minimax like this (I've added comments in the code to help explain it):

// As I said erlier, the algorithm will take the board, the ismax parameter to check if we want to maximize or minimize for a certain turn

function minimax(board,depth,ismax){

    // This is a recursive function, so we should set the bases cases first which will be getting a draw a win or reaching the depth

    // As you've seen in the visualizations, when there is a draw or winning conditions no more child boards are generated. So if a winning condition occured when it's X's turn. It got to be X who won that's why I returned 1, and the same logic applies for when Y won and I returned -1 when we were minimizing.

    if (checkwin()) return ismax ? 1 : -1
    if (boardfull()) return 0

    if(ismax){

        // When we're maximizing we will set a counter to -Infinity and whenever we encounter a board value higher than the counter, we will consider it as the best move

     let best=-Infinity
     board.forEach((elem,index)=>{

         //Now to check all resulting positions we will iterate over the board and whenever there is an avaible slot we will set it to X and run minimax on this position. Look how I incrimented the depth

     if(elem ==''){
       board[index]='X'
       let  localscores=minimax(test,depth+1,false)

       // Here I am reetting the board to the same position 

       board[index]=''
       best=max(best,localscores)
     }})
     return best
     }

 // This else here means we're minimizing

 else{

     // Here we will set our counter to + Infinity because we want to find the lowest possible value

    let best=Infinity
    board.forEach((elem,index)=>{
    if(elem ==''){
     board[index]=humanicon
     let localscores=minimax(test,depth+1,true)
     board[index]=''
     best=min(best,localscores)
    }})
    return best
  }
}

And now we're done!

Conclusion

In this article, we’ve learned about the minimax algorithm, its mechanism, limitations, and how to improve it. Now you can go and customize this to work on various games to create some cool game bots.

In the end, I hope you learned something new from this article.

If you found this useful and want to get more awesome content, follow me on LinkedIn. It will help a lot.

In this article we will talk about why and how to implement the GameCenter's Leaderboard within your app.

Why GameCenter is Making a Huge Revival

You can make iPhone games without a scoreboard, but leaderboards can help make the game feel more competitive, like people are competing against one another around the World.

Instead of creating and managing your own backend, the GameCenter Leaderboard allows you to scale with traffic infinitely, skip an entire login page for authorization, get the Image, Name, and friends playing the same game – all without your users having to enter anything.

Especially with iOS 16, Apple is investing more in improving it, and driving more app usage, like through Push Notifications when your friend beats your score in the game.

In my journey of learning SwiftUI, I have been creating and publishing apps, because IMO that's the best way to learn.

There wasn't much updated documentation on how to do a lot of this, especially none with SwiftUI nor with the advent of async and await in Swift. So I consolidated and simplified it for everyone to build amazing apps. So feel free to invite me to test your apps too!

Pre-Requisites:

• You'll need to have an Apple Developer paid account
• You have to create the App Id for your app in the provisioning profiles section of the Apple Developer Portal
• You have to create the App in the iTunes Connect Connect portal

How to Implement Your iOS Leaderboard in 6 Steps

Most of the code logic for the leaderboard is in this file if you want to skip ahead. Here's the steps as follows:

1. How to Create the App Store Connect Leaderboard

Screenshot from the Apple iTunes Connect Portal

Once you have created the app in the App Store Connect portal successfully, go to the Services tab for the app -> and make sure you're in the GameCenter page.

Then add a new leaderboard using the "+" sign, which can either be "Classic" (scores never reset) or "Recurring" (scores reset based on your frequency settings).

Most games prefer a recurring leaderboard so that the leaderboard isn't cluttered with older impossible to reach high scores.

The LeaderboardID you input there is the one that you need to use in all the places in the code that ask for it.

Details required to create a new Leaderboard

2. How to Set Up GameCenter Authentication

First, you'll need to authenticate users to GameCenter in order for any of this functionality to work.

So we'll use this code to do that, which basically makes sure that you (GKLocalPlayer.local) are authenticated, or prints an error if there is one:

func authenticateUser() {
    GKLocalPlayer.local.authenticateHandler = { vc, error in
        guard error == nil else {
            print(error?.localizedDescription ?? "")
            return
        }
    }
}

If the user is authenticated, you will see a little popup in the UI. If not, the user will be taken to a page to login to their GameCenter account.

A sign that displays when a user is logged in

3. How to Display Leaderboard Items in the UI

In order to get the data away from the GameCenter ViewController leaderboards (GKLeaderboard), you need to use the loadLeaderboards .

You can switch up the loadEntries function from .global to .friends in order to only pull your friends.

You can also retrieve the image for each player by iterating over each player and performing a loadPhoto.

Using NSRang(1...5), you can choose how many players to display. This pulls the users with the highest 5 scores from the leaderboard and returns none if there's no users, such as in the case when the cycle refreshes for a recurring Leaderboard.

This is what pulling data from a leaderboard could look like if you take advantage of async-await:

func loadLeaderboard() async {
    playersList.removeAll()
    Task{
        var playersListTemp : [Player] = []
        let leaderboards = try await GKLeaderboard.loadLeaderboards(IDs: [leaderboardIdentifier])
        if let leaderboard = leaderboards.filter ({ $0.baseLeaderboardID == self.leaderboardIdentifier }).first {
            let allPlayers = try await leaderboard.loadEntries(for: .global, timeScope: .allTime, range: NSRange(1...5))
            if allPlayers.1.count > 0 {
                try await allPlayers.1.asyncForEach { leaderboardEntry in
                    var image = try await leaderboardEntry.player.loadPhoto(for: .small)
                    playersListTemp.append(Player(name: leaderboardEntry.player.displayName, score:leaderboardEntry.formattedScore, image: image))
                                print(playersListTemp)
                    playersListTemp.sort{
                        $0.score < $1.score
                    }
                }
            }
        }
        playersList = playersListTemp            
    }
}

You can get leaderboard data into your app

4. How to Call Functionality in SwiftUI as the View/Page Appears

You can take advantage of the onAppear lifecycle function of the view to actually make the calls to authenticate and load, but you can also do it on the tap of a button if you prefer that:

.onAppear(){
    if !GKLocalPlayer.local.isAuthenticated {
        authenticateUser()
    } else if playersList.count == 0 {
        Task{
            await loadLeaderboard()
        }
    }
}

5. How to Load the Submitted Scores

In order to load the scores, you need to submit them as well. The submitScore function can help you with that.

• The flightsClimbed variable should contain the score that you would like to submit.
• GameKit makes sure to only display your best score for the life of the leaderboard.
• The leaderboardId contains the value that you manually enter in your App Store Connect account:

func leaderboard() async{
    Task{
        try await GKLeaderboard.submitScore(
            flightsClimbed,
            context: 0,
            player: GKLocalPlayer.local,
            leaderboardIDs: ["com.tfp.stairsteppermaster.flights"]
        )
    }
    calculateAchievements()
}

6. How to display the GameCenter ViewController Portal

When you're logged into GameCenter, a little annoying icon appears in the top right of your screen. When you tap on it, you are taken to the GameCenter ViewController. Luckily you can hide it if it's not part of your design, using GKAccessPoint.shared.isActive = false.

Since the GameCenter UI is a UIKit ViewController and not a simple SwiftUI View, you need to create this UIViewControllerRepresentable first (as you can see here), to launch GameCenter using a different button,

Once you add that file to your project, you can display the GameCenter portal simply using this: GameCenterView(format: gameCenterViewControllerState) where gameCenterViewControllerState can be help you go to a detail page in GameCenter.

GameCenter's Leaderboard View

Things to Keep in Mind While using GameCenter's Leaderboards:

• Simulator Debugging – For some reason the authenticate to GameCenter is extremely slow on a simulator, so it might make sense to even create a mock of data when using the simulator.
• Challenges – You can't programmatically issue GameKit Challenges to your friends anymore due to deprecation. Instead, you have to do those manually within the user's GameCenter dashboard against GameKit Achievements. Also, there's no way to view challenges you have sent.
• Achievements – Leaderboards are different from the GameKit Achievements, which is calculated and displayed differently, but a lot easier. Those can also be pulled into the app as well, as you can see below:

GameKit Challenges and Achievements

Wrapping Up

You can try out the free open-source Stair Master Climber iPhone Health & Fitness app that I shared above. I would love to know what you think so that we can learn together.

Feel free to reach out to me on social media or by email if you have any questions.

If you have an Android phone, one of your guilty pleasures might be playing some very entertaining games. Or it could be that there is an application that only runs on your phone.

And then you think – what if you could run the same games on your desktop PC?

To simplify the scenario, let's assume the applications run on Android.

One approach to solve your problem is to run an Android emulator on your PC. But some of them, like Android-x86, require rebooting your machine so they can take control of the hardware.

If you don't mind a small performance hit you can run a virtual machine at the same time as your native operating system. Specifically on Linux, there are several choices, like QEMU and VirtualBox, to name a few.

By the end of this article you will be able to do the following:

• Install VirtualBox on Fedora Linux

• Run android-x86 and finish the basic setup

• Install an application from the Google Play Store, just like on your phone.

Basic Requirements

Before you start, I assume that you have the following:

• Ability to run commands as the superuser (like SUDO)

• An account on Google.com, so you can use the Play store from within the virtual machine.

How to Install VirtualBox

The first step is to install VirtualBox. For practical purposes, our installation will be basic, just enough to run our games:

sudo dnf install -y kernel-devel kernel-devel-5.14.18-100.fc33.x86_64
curl --remote-name --location https://www.virtualbox.org/download/oracle_vbox.asc
sudo rpm --import ./oracle_vbox.asc
sudo dnf install -y https://download.virtualbox.org/virtualbox/6.1.36/VirtualBox-6.1-6.1.36_152435_fedora33-1.x86_64.rpm
sudo dnf install -y virtualbox-guest-additions.x86_64
sudo /sbin/vboxconfig

How to Install the Android-x86 ISO

The first step is to download the ISO image from Android-x86. This ISO contains the Android operating system that will be installed on our virtual hard drive.

After that we can set up our virtual machine like this:

How a finished virtual machine looks like on VirtualBox

A few things to note:

• After booting the first time, I found that 1GB for the Android image was not enough. Performance improved a lot after I bumped the ram to 3GB.

• Another change was the 'Graphics Controller'. Originally it was VMSVGA but then Android refused to start in graphic mode, so I switched to VboxVGA and it worked.

• 2 CPUS and 8GB of disk space were enough for my game.

• Finally, I specified that the IDE controller was the android-x86 ISO.

To start the virtual machine, you click the 'Start' button on the GUI, and then you will have to make a few decisions like bootable partition:

Partitioning your virtual disk. We assign 8 GB and make sure the partition can boot

Once this is done you can choose your new partition to perform the installation:

After the new partition is created, you can choose it and you can install the Android OS there

Then the installation will proceed:

The installer copies the files from the Android ISO image into the virtual hard drive

After the installation is complete, you can shut down the virtual machine.

First Boot

Now you'll need to go to the advanced options and select the virtual disk (instead of the ISO image) to boot:

You can either boot from disk on this menu or change the boot order on the virtual machine

After that, Android will ask you some basic setup information, just like it does on your phone. The final result may look like this:

The virtual machine looks exactly like your Android phone.

How to Install Games from the Google Play Store

In my case I decided to install a game where I can fight forces of evil as 1970 Mazinger Z/ Tranzor Z (Yes, I love Go Nagai Mazinger Z). To do that, search on the play store and install the game:

After Android is running and your credentials are set you can download and install any Android program you want.

And now, success! We got the game up and running.

Sorry, but now it is time to play as Mazinger Z!

What Did We Learn Here?

• We managed to install a virtual machine engine and successfully run the Android operating system along with our regular Fedora OS

• You saw how you can try and discard whole operating systems' setup, without going through the hassle of setting up a dual boot system with Grub on Linux

Another nice feature of running the game inside a virtual machine is that you can fully freeze the game, then come back and restore it at exactly the same point where you left it.

Finally, you can do many more things with a virtual machine than just running games, for example:

• You can analyze malware safely, run un-trusted applications, and contain any damage they can cause.

• Try a new operating system version before deciding to commit a proper installation (not a big issue these days as most of them provide a lice CD you can boot to try), but this is still very convenient.

• Be able to run multiple operating systems simultaneously, without rebooting your machine. You most likely will start trying more advanced options of your virtual machine of choice, like VirtualBox.

Playing games on your PC is a gateway for learning more complex stuff later. Also the fun factor is undeniable. Enjoy!

This is what we'll make in this tutorial:

Snake is a fun game which you might have played on older feature phones like on Nokia 3310 models.

The concept behind it is simple: the snake roams around inside a box, and once it captures the fruit/object your points increase and the snake grows. If the snake hits the boundaries of the box or collides with itself then the game is over.

This article will provide you with all the necessary skills/steps to create your own Snake game from scratch. We'll first look at the code structures and their logic. Then I'll explain how they work when all of them are connected.

Without further ado, let’s get started.

Table of contents

• Prerequisites
• What is a snake game? What are we going to use in it?
• What is redux? Why are we using this?
• What is redux-saga? Why are we using this?
• Use case description
• The application and data layer set up
• Understanding UI Layer
• Canvas Board
• Drawing the objects
• Moving the snake across the board
• Drawing the fruit at a random position
• Score calculator
• Instruction component
• Final Game
• Summary

Prerequisites

Before you start reading this article, you should have a basic understanding of the following topics:

• Class Diagrams: We are going to use them to showcase our example. Here are a couple of resources you can use to learn more about them:
  • Class diagrams
  • UML Diagram course
• Context Diagram and Container Diagrams
• React
• Generators:
  • Generators
  • Function generators

What is a snake game? What are we going to use in it?

A snake game is an arcade game that involves a snake moving inside a box. Your score increases based on how many objects/fruit the snake eats. This will also increase the size of the snake. If it collides with itself or to the boundary of the box then the game is over.

You can read more about the history or the origins of the game in the Wiki link.

We are going to use the following tools to build our game:

• Redux: To create and manage the global state for the application.
• Redux-saga: A redux middleware we'll use to manage async tasks.
• Canvas HTML tag: We'll use this to draw an object like a snake and the fruit.
• React: UI library.
• Chakra-UI: Component library.

What is redux? Why are we using it?

Redux is a state container that helps you create and manage global state for your application. Redux consists of some basic parts like:

1. Global State
2. Redux store
3. Actions and action creators
4. Reducers

You can learn all about the above topics and how Redux works internally from the Redux doc’s getting started section.

We are using the state management library Redux because it will help us manage our global state in a simpler way. It will allow us to avoid prop drilling. It will also allow us to perform complex async actions via middleware.

You can learn more about middleware here.

What is redux-saga? Why are we using it?

Redux-saga is a middleware that helps us tap in between the dispatched action and the reducer of the redux store. This allows us to perform certain side-effects between the dispatched action and the reducer such as data fetching, listening to particular actions or setting up subscriptions, spawning actions, and more.

Redux saga uses generators and generator functions. A typical saga would look like this:

function* performAction() {
    yield put({
        type: COPY_DATA,
        payload: "Hello"
    });
}

performAction is a generator function. This generator function will execute the put function. It creates an object and returns it to the saga, telling what type of action needs to be executed with what payload. Then the put call returns an object descriptor saying which saga can take it up later and execute the particular action.

NOTE: You can read more about generators and generator functions by referring to the prerequisite section.

Now the question arises Why are we using redux-saga middleware? The answer is simple:

1. It provides a better way to write unit test cases, which will help us test the generator functions in a simpler way.
2. It can help you perform a lot of side effects and provide better control over the changes. One example is whenever you want to watch if a particular action X is executed then perform the action Y. Functions like takeEvery, all, and so on make it simple to perform these operations. We will discuss more of this in a later section.

If you are not familiar with redux-saga, then I highly recommend going through the documentation here.

Use case description

NOTE: Context, Container, and Class diagrams drawn in this blog post don't accurately follow the exact conventions of these diagrams. I've approximated them here so you can understand the basic concepts.

Before we start, I would suggest reading up on c4models, container diagrams, and context diagrams. You can find resources about them in the prerequisites section.

In this article we are going to consider the following use case: Create a snake game.

The use case is pretty self-explanatory, and we have discussed what the snake game entails above. Below is the context diagram for our use case:

Snake game context diagram

Our context diagram is pretty straightforward. The player interacts with the UI. Let's dive deeper into the container game board UI and explore what other systems are present inside it.

Container diagram for the snake game

As you can see from the above diagram, our Game Board UI is divided into two Layers:

1. UI Layer
2. Data Layer

The UI Layer consists of the following components:

1. Score Calculator: This is a component that will display the score whenever the snake eats the fruit.
2. Canvas Board: This is a component that handles the major UI part of our game. Its basic functionality is to draw the snake on the canvas and clear the canvas. It also handles the following responsibilities:
   1. It detects if the snake has collided with itself or with the boundary walls (Collision detection).
   2. Helps in moving the snake along the board with keyboard events.
   3. Resets the game when the game is over.
3. Instructions: It provides the instructions for playing the game, along with the reset button.
4. Utilities: These are the utility functions that we'll use throughout the application wherever needed.

Let's now talk about the Data Layer. It consists of the following components:

1. Redux-saga: Set of generator functions that will perform certain actions.
2. Actions and Action Creators: These are the set of constants and functions which will help in dispatching appropriate actions.
3. Reducers: This will help us respond to the various actions dispatched by action creators and the sagas.

We will deep dive into all of these components and see how they work collectively in the later sections. First, let's initialize our project and set up our Data layer – that is, the Redux store.

The application and data layer set up

Before we start understanding our game components, let's first set up our React application and the data layer.

The game is built with React. I highly recommend using the create-react-app template to install all the necessary things to start your React application.

To create a CRA (create-react-app) project, first we need to install it. Type the below command into your terminal:

npm install -g create-react-app

Note: Before running this command make sure you have installed Node.js in your system. Follow this link to install it.

Next, we will start by creating our project. Let's call it snake-game. Type the below command into your terminal to create the project:

npx create-react-app snake-game

This may take few minutes to complete. Once this is completed, traverse to your newly created project using the below command:

cd snake-game

Once inside the project, type the below command to start the project:

npm run start

This command will open a new tab in your browser with the React logo spinning on the page like below:

create-react-app initial page

Now our initial project setup is complete. Let's configure our data layer (the Redux store). Our data layer requires that we install the following packages:

• Redux
• Redux-saga

First, let's start off by installing these packages. Before we start, make sure you are in the project directory. Type the below command in the terminal:

npm install redux react-redux redux-saga

Once these packages are installed then we will first configure our Redux store. To start off, let's first create a folder named store:

mkdir store

This store folder will consist of all the files related to Redux. We will organize our store folder in the following manner:

store/
├── actions
│   └── index.ts
├── reducers
│   └── index.ts
└── sagas
    └── index.ts
├── index.ts

Let's discuss what each of the files does:

• action/index.tsx: This file consists of constants that represents actions that our application can perform and dispatch to the Redux store. An example of such an action constant looks like this:

export const MOVE_RIGHT = "MOVE_RIGHT"

We will use the same action constant to create a function which will return an object with the following properties:

• type: Action type, that is action constant
• payload: additional data that acts as a payload.

These functions which return an object with the type property are called action creators. We use these functions to dispatch actions to our Redux store.

The payload attribute signifies that along with the action we can also pass additional data which can be used to store or update the value inside the global state.

NOTE: It is mandatory to have type property returned from the action creator. The payload property is optional. Also, the name of the payload property can be anything.

Let's see an example of an action creator:

//Without payload
export const moveRight = () => ({
    type: MOVE_RIGHT
});

//With payload
export const moveRight = (data: string) => ({
    type: MOVE_RIGHT,
    payload: data
});

Now that we know what actions and action creators are, we can move on to configuring our next artifact which is a reducer.

Reducers are functions that return a new global state every time an action is dispatched. They take in the current global state and return the new state based on the action that is dispatched/called. This new state is calculated based on the previous state.

We should be careful here that we do not perform any side-effects inside this function. We should not alter the global state – rather we should return the updated state as a new object itself. Therefore, the reducer function should be a pure function.

Now enough talking about reducers. Let's have a look at our sample reducers:

const GlobalState = {
    data: ""
};

const gameReducer = (state = GlobalState, action) => {
    switch (action.type) {
        case "MOVE_RIGHT":
            /**
             * Perform a certain set of operations
             */
            return {
                ...state, data: action.payload
            };

        default:
            return state;
    }
}

In this example, we have created a reducer function which is called a gameReducer. It takes in the state (default parameter as a global state) and an action. Whenever we have action.type that matches the switch case, then it performs a particular action, like returning a new state based on the action.

The sagas/index.ts file will consist of all the sagas that we will use in our application. We do have some basic understanding of the sagas which we briefly explained in the above sections. We will dive deeper into this section when we actually start our implementation of the snake game.

Now we have a basic understanding of the artifacts involved in making our Redux store. Let's go ahead and create store/index.ts like below:

import {
    createStore,
    applyMiddleware
} from "redux";
import createSagaMiddleware from "redux-saga";
import gameReducer from "./reducers";
import watcherSagas from "./sagas";
const sagaMiddleware = createSagaMiddleware();

const store = createStore(gameReducer, applyMiddleware(sagaMiddleware));

sagaMiddleware.run(watcherSagas);
export default store;

We will first import our reducer and the saga. Next we will use the createSagaMiddleware() function to create a saga middleware.

Next, we will connect it to our store by passing it as an argument to the applyMiddleware function inside createStore which you use to create a store. We will also pass gameReducer to this function so that a reducer is mapped to our store.

Finally, we will run our sagaMiddleware using this code:

sagaMiddleware.run(watcherSagas);

Our final step is to inject this store at the top level of our React app using the Provider component provided by react-redux. You can do this as follows:

import { Provider } from "react-redux";
import store from "./store";

const App = () => {
  return (
    <Provider store={store}>
    //   Child components...
    </Provider>
  );
};

export default App;

I have also installed chakra-UI as a UI component library for our project. To install chakra-UI, type the below command:

npm install @chakra-ui/react @emotion/react@^11 @emotion/styled@^11 framer-motion@^5

We also need to setup the ChakraProvider that will go in our App.tsx file. Our updated App.tsx file will look like this:

import { ChakraProvider, Container, Heading } from "@chakra-ui/react";
import { Provider } from "react-redux";
import store from "./store";

const App = () => {
  return (
    <Provider store={store}>
      <ChakraProvider>
        <Container maxW="container.lg" centerContent>
          <Heading as="h1" size="xl">SNAKE GAME</Heading>
    //Children components
        </Container>
      </ChakraProvider>
    </Provider>
  );
};

export default App;

Understanding UI layer

Let's first understand the dynamics of our Snake game from the UI perspective. Before we get started, our final Snake game will look like below:

The UI Layer consists of 3 layers: Score Calculator, Canvas Board, and Instructions. The below diagram showcases these sections:

Let's dive deeper into each of these sections to understand how our Snake game works.

Canvas Board

We'll start off by understanding the Canvas Board:

• Our canvas board is going to be of dimensions height: 600, width: 1000
• This entire board is divided into blocks of 20x20 size. That is, every object that is drawn on this board has height 20 and width 20.
• We are using the <canvas> HTML element to draw the shapes in the canvas board component.

In our project, we are writing the canvas board component inside the file components/CanvasBoard.tsx. Now that our basic understanding is clear about the CanvasBoard component, let's start building this component.

Create a simple component that returns a canvas element as below:

export interface ICanvasBoard {
  height: number;
  width: number;
}

const CanvasBoard = ({ height, width }: ICanvasBoard) => {
  return (
    <canvas
      style={{
        border: "3px solid black",
      }}
      height={height}
      width={width}
    />
  );
};

Call this component in our App.tsx file with width and height of 1000 and 600 as a prop like below:

import { ChakraProvider, Container, Heading } from "@chakra-ui/react";
import { Provider } from "react-redux";
import CanvasBoard from "./components/CanvasBoard";
import ScoreCard from "./components/ScoreCard";
import store from "./store";

const App = () => {
  return (
    <Provider store={store}>
      <ChakraProvider>
        <Container maxW="container.lg" centerContent>
          <Heading as="h1" size="xl">SNAKE GAME</Heading>
          <CanvasBoard height={600} width={1000} /> //Canvasboard component added 
        </Container>
      </ChakraProvider>
    </Provider>
  );
};

export default App;

This will create a simple box of height=600 and width=1000 with a black border like below:

A blank canvas element with width=1000 and height=600

Now let's draw a snake at the center of this canvas. But before we can start drawing, we need to get the context of this canvas element.

The context of a canvas element provides you with all the information you need related to the canvas element. It gives you the dimensions of the canvas and also helps you draw on the canvas.

To get the context of our canvas element we need to call the getCanvas('2d') function which returns the 2d context of the canvas. The return type of this function is CanvasRenderingContext2D interface.

To do this in pure JS we would do something like below:

const canvas = document.querySelector('canvas');
const canvasCtx = canvas.getContext('2d');

But to do so in React we need to create a ref and pass it to the canvas element so that we can address it later in different hooks. To do so in our application, create one ref using the useRef hook:

const canvasRef = useRef<HTMLCanvasElement | null>(null);

Pass the ref into our canvas element:

<canvas
  ref={canvasRef}
  style={{
    border: "3px solid black",
  }}
  height={height}
  width={width}
/>;

Once the canvasRef is passed into the canvas element, we can use it inside a useEffect hook and store the context in a state variable.

export interface ICanvasBoard {
  height: number;
  width: number;
}

const CanvasBoard = ({ height, width }: ICanvasBoard) => {
  const canvasRef = (useRef < HTMLCanvasElement) | (null > null);
  const [context, setContext] =
    (useState < CanvasRenderingContext2D) | (null > null);

  useEffect(() => {
    //Draw on canvas each time
    setContext(canvasRef.current && canvasRef.current.getContext("2d")); //store in state variable
  }, [context]);

  return (
    <canvas
      ref={canvasRef}    
      style={{
        border: "3px solid black",
      }}
      height={height}
      width={width}
    />
  );
};

Drawing the objects

After getting the context we need to do the following tasks each time a component updates:

1. Clear the canvas
2. Draw the snake with the current position
3. Draw a fruit at a random position inside the box

We are going to clear the canvas multiple times, so we will make this a utility function. So for that, let's create a folder called utilities:

mkdir utilities
cd utilities
touch index.tsx

The above command will also create an index.tsx file inside the utilities folder. Add the below code in the utilities/index.tsx file:

export const clearBoard = (context: CanvasRenderingContext2D | null) => {
  if (context) {
    context.clearRect(0, 0, 1000, 600);
  }
};

The clearBoard function is pretty straightforward. It does the following actions:

1. It accepts the 2d canvas context objects as an argument.
2. It checks that the context is not null or undefined.
3. The clearRect function will clear all the pixels or objects present inside the rectangle. This function will take width and height as an argument for the rectangle to be cleared.

We will use this clearBoard function inside our CanvasBoard useEffect to clear the canvas every time the component is updated. For differentiating between different useEffects, we will name the above useEffect as useEffect1.

Now let's start by drawing the snake and the fruit at a random position. Since we are going to draw the objects multiple times, we'll create a utility function called drawObject for it. Add the below code in the utilities/index.tsx file:

export interface IObjectBody {
  x: number;
  y: number;
}

export const drawObject = (
  context: CanvasRenderingContext2D | null,
  objectBody: IObjectBody[],
  fillColor: string,
  strokeStyle = "#146356"
) => {
  if (context) {
    objectBody.forEach((object: IObjectBody) => {
      context.fillStyle = fillColor;
      context.strokeStyle = strokeStyle;
      context?.fillRect(object.x, object.y, 20, 20);
      context?.strokeRect(object.x, object.y, 20, 20);
    });
  }
};

The drawObject function accepts the following arguments:

1. context – A 2D canvas context object for drawing the object on the canvas.
2. objectBody – This is an array of objects with each object having x and y properties, like the IObjectBody interface.
3. fillColor – Color to be filled inside the object.
4. strokeStyle – Color to be filled in the outline of the object. Defaults to #146356.

This function will check if the context is undefined or null. Then it iterates over the objectBody via forEach. For each object it performs the following operations:

1. It will assign the fillStyle and strokeStyle inside the context.
2. It will use fillReact to create a filled rectangle with coordinates object.x and object.y with size 20x20
3. Finally, it will use strokeRect to create an outlined rectangle with coordinates object.x and object.y with size 20x20

For drawing the snake we need to maintain the position of the snake. For that, we can use our global state management tool redux.

We need to update our reducers/index.ts file. Since we want to track the position of the snake, we will add it into our global state as follows:

interface ISnakeCoord {
  x: number;
  y: number;
}

export interface IGlobalState {
  snake: ISnakeCoord[] | [];
}

const globalState: IGlobalState = {
  //Postion of the entire snake
  snake: [
    { x: 580, y: 300 },
    { x: 560, y: 300 },
    { x: 540, y: 300 },
    { x: 520, y: 300 },
    { x: 500, y: 300 },
  ],
};

Let's call this state in our CanvasBoard component. We will use the useSelector hook of react-redux to get the required state from the store. The following will give us the snake's global state:

const snake1 = useSelector((state: IGlobalState) => state.snake);

Let's embed this in our CanvasBoard component and pass it to our drawObject function and see the output:

//Importing necessary modules
import { useSelector } from "react-redux";
import { clearBoard, drawObject, generateRandomPosition } from "../utils";

export interface ICanvasBoard {
  height: number;
  width: number;
}

const CanvasBoard = ({ height, width }: ICanvasBoard) => {
    const canvasRef = useRef<HTMLCanvasElement | null>(null);
    const [context, setContext] = useState<CanvasRenderingContext2D | null>(null);
    const snake1 = useSelector((state: IGlobalState) => state.snake);
    const [pos, setPos] = useState<IObjectBody>(
        generateRandomPosition(width - 20, height - 20)
      );

    useEffect(() => {
      //Draw on canvas each time
     setContext(canvasRef.current && canvasRef.current.getContext("2d")); //store in state variable
        drawObject(context, snake1, "#91C483"); //Draws snake at the required position
        drawObject(context, [pos], "#676FA3"); //Draws fruit randomly
    }, [context])

  return (
    <canvas
      style={{
        border: "3px solid black",
      }}
      height={height}
      width={width}
    />
  );
};

Let's see what the output will look like when the snake is drawn:

Drawing snake

Moving the snake across the board

Now that we have our snake drawn onto the canvas, let's learn how to move the snake across the board.

The movement of the snake is simple. It should always follow the below points:

1. If the snake is moving horizontally, then it can only move up, down, and in the direction it is currently moving. For example, if the snake is moving to the right then it can move up or down or continue moving to the right.
2. If the snake is moving vertically, then it can only move to the right, left or continue in the direction it's currently moving. For example, if the snake is moving up then it can move right or left (or continue up).
3. The snake cannot move in the direction opposite to that of the current direction. That is, if the snake is moving to the left then it cannot move to the right straight away. Likewise, if it's going up it cannot move down.

For the smooth movement of our snake, the snake should always move in a rectangular fashion. And it needs to meet the above points to have that movement.

The below diagram helps summarise how the movement of the snake works in the entire application:

Snake movement explanation

NOTE: In the above diagram, the entire movement of the snake starts with the CanvasBoard component.

HINT: Don't worry if you cannot follow the above diagram. Just read the later sections to get more clarity.

To maintain the movement of the snake, we will introduce another state variable to our global state called disallowedDirection. The purpose of this variable is to keep track of the opposite direction of the snake's movement.

For example if the snake is moving left then the disallowedDirection will be set to right. So to summarise, we are tracking this direction so that we can avoid the snake moving in its opposite direction.

Let's create this variable in our global state:

interface ISnakeCoord {
  x: number;
  y: number;
}

export interface IGlobalState {
  snake: ISnakeCoord[] | [];
  disallowedDirection: string;
}

const globalState: IGlobalState = {
    //Postion of the entire snake
  snake: [
    { x: 580, y: 300 },
    { x: 560, y: 300 },
    { x: 540, y: 300 },
    { x: 520, y: 300 },
    { x: 500, y: 300 },
  ],
    disallowedDirection: ""
};

Now let's create some actions and action creators that will help us move the snake.

We will have two types of actions for this case:

• Actions for sagas
  • These are the actions that will be dispatched from the CanvasBoard component. These actions will be:
    • MOVE_RIGHT
    • MOVE_LEFT
    • MOVE_UP
    • MOVE_DOWN
• Actions for reducers
  • These are the actions that will be yielded by the saga to propagate the calls to the reducers. These actions will be:
    • RIGHT
    • LEFT
    • UP
    • DOWN

We will take a closer look at these actions in the coming sections.

We will be creating one more action called SET_DIS_DIRECTION to set the disallowedDirection state.

Let's create some action creators for the movement of the snake:

• setDisDirection – This action creator will be used to set the disallowedDirection via the SET_DIS_DIRECTION action. Below is the code for this action creator:

export const setDisDirection = (direction: string) => ({
  type: SET_DIS_DIRECTION,
  payload: direction
});

• makeMove – This will be used to set/update the new coordinates of the snake by updating the snake state variable. Below is the code for this action creator:

export const makeMove = (dx: number, dy: number, move: string) => ({
  type: move,
  payload: [dx, dy]
});

The parameters dx and dy are the deltas. They tell the Redux store by how much we should increase/decrease the coordinates of each snake block to move the snake in the given direction.

The move parameter is used to specify in which direction will the snake be moving. We will have a look at these actions creators soon in the coming sections.

Finally, our updated actions/index.ts file will look something like this:

export const MOVE_RIGHT = "MOVE_RIGHT";
export const MOVE_LEFT = "MOVE_LEFT";
export const MOVE_UP = "MOVE_UP";
export const MOVE_DOWN = "MOVE_DOWN";

export const RIGHT = "RIGHT";
export const LEFT = "LEFT";
export const UP = "UP";
export const DOWN = "DOWN";

export const SET_DIS_DIRECTION = "SET_DIS_DIRECTION";

export interface ISnakeCoord {
  x: number;
  y: number;
}
export const makeMove = (dx: number, dy: number, move: string) => ({
  type: move,
  payload: [dx, dy]
});

export const setDisDirection = (direction: string) => ({
  type: SET_DIS_DIRECTION,
  payload: direction
});

Now, let's have a look at the logic we are using to move the snake based on the above actions. All the snake movement will be tracked by the following actions:

• RIGHT
• LEFT
• UP
• DOWN

All these actions are the building blocks of the snake's movement. These actions, when dispatched, will always update the snake's global state based on the logic we are describing below. And they will calculate new coordinates of the snake on each movement.

To calculate the new coordinates of the snake after each movement, we will use the following logic:

1. Copy the coordinates into a new variable called newSnake
2. Add at the start of the newSnake the new x and y coordinates. These x and y attributes of these coordinates are updated by adding the x and y values from the action's payload.
3. Finally, remove the last entry from the newSnake array.

Now that we have some understanding of how the snake is moving, let's add the following cases in our gameReducer:

    case RIGHT:
    case LEFT:
    case UP:
    case DOWN: {
      let newSnake = [...state.snake];
      newSnake = [{
        //New x and y coordinates
        x: state.snake[0].x + action.payload[0],
        y: state.snake[0].y + action.payload[1],
      }, ...newSnake];
      newSnake.pop();

      return {
        ...state,
        snake: newSnake,
      };
    }

For every movement of the snake, we update the new x and y coordinates which are increased by payloads action.payload[0] and action.payload[1]. We successfully completed setting up the actions, actions creators, and the reducer logic.

We are good to go and can now use all of this in our CanvasBoard component.

First, let's add a useEffect hook in our CanvasBoard component. We will use this hook to attach/add an event handler. This event handler will be attached to the event keypress. We are using this event because whenever we press the w a s d keys we should be able to control the movement of the snake.

Our useEffect will look something like below:

useEffect(() => {
    window.addEventListener("keypress", handleKeyEvents);

    return () => {
      window.removeEventListener("keypress", handleKeyEvents);
    };
  }, [disallowedDirection, handleKeyEvents]);

It works in the following manner:

1. On the mounting of the component, the event listener with callback function handleKeyEvents is attached to the window object.
2. On the unmounting of the component, the event listener is removed from the window object.
3. If there is any change in the direction or handleKeyEvents function, we will re-run this useEffect. Therefore, we have added disallowedDirection and handleKeyEvents into the dependency array.

Let's have a look at how the handleKeyEvents callback is created. Below is the code for the same:

const handleKeyEvents = useCallback(
    (event: KeyboardEvent) => {
      if (disallowedDirection) {
        switch (event.key) {
          case "w":
            moveSnake(0, -20, disallowedDirection);
            break;
          case "s":
            moveSnake(0, 20, disallowedDirection);
            break;
          case "a":
            moveSnake(-20, 0, disallowedDirection);
            break;
          case "d":
            event.preventDefault();
            moveSnake(20, 0, disallowedDirection);
            break;
        }
      } else {
        if (
          disallowedDirection !== "LEFT" &&
          disallowedDirection !== "UP" &&
          disallowedDirection !== "DOWN" &&
          event.key === "d"
        )
          moveSnake(20, 0, disallowedDirection); //Move RIGHT at start
      }
    },
    [disallowedDirection, moveSnake]
  );

We have wrapped this function with a useCallback hook. This is because we want the memoized version of this function which is called on every state change (that is, on the change of disallowedDirection and moveSnake). This function is called on every key pressed on the keyboard.

This event handler callback function serves the following purpose:

• If the disallowedDirection is empty then we make sure that the game will start only when the user presses the d key. This means that the game starts only when the snake moves to the right.

NOTE: Initially the global state variable disallowedDirection value is an empty string. In this way, we know that if its value is empty then it's the start of the game.

Once the game starts, the disallowedDirection won’t be empty and then it listens to all the keyboard presses such as w s and a.

Finally, on every keypress, we are calling the function called moveSnake. We will take a closer look into it in the next section.

The moveSnake function is a function that dispatches an action passed to the makeMove action creator. This function accepts three arguments:

1. dx - Delta for x-axis. This tells by how much the snake should move along the x-axis. If dx is positive then it moves to the right, if it's negative it moves to the left.
2. dy - Delta for the y-axis. This tells by how much the snake should move along the y-axis. If dy is positive then it moves down, if it's negative it moves up.
3. disallowedDirection - This value tells that the snake should not move in the opposite direction. This is an action that is captured by our middleware saga.

The code for the moveSnake function will look like this:

const moveSnake = useCallback(
    (dx = 0, dy = 0, ds: string) => {
      if (dx > 0 && dy === 0 && ds !== "RIGHT") {
        dispatch(makeMove(dx, dy, MOVE_RIGHT));
      }

      if (dx < 0 && dy === 0 && ds !== "LEFT") {
        dispatch(makeMove(dx, dy, MOVE_LEFT));
      }

      if (dx === 0 && dy < 0 && ds !== "UP") {
        dispatch(makeMove(dx, dy, MOVE_UP));
      }

      if (dx === 0 && dy > 0 && ds !== "DOWN") {
        dispatch(makeMove(dx, dy, MOVE_DOWN));
      }
    },
    [dispatch]
  );

The moveSnake is a simple function that checks for the conditions:

1. If dx > 0, and the disallowedDirection is not RIGHT, then it can move in the RIGHT direction.
2. If dx < 0, and the disallowedDirection is not LEFT, then it can move in the LEFT direction.
3. If dy > 0, and the disallowedDirection is not DOWN, then it can move in the DOWN direction.
4. If dy < 0, and the disallowedDirection is not UP, then it can move in the UP direction.

This disallowedDirection value is set in our sagas which we'll talk about more in the later sections of this article. If we revisit the handleKeyEvents function now it makes much more sense. Let's walk through an example over here:

• Suppose you want to move the snake to the RIGHT. Then this function will detect that the d key is pressed.
• Once this key is pressed it calls the makeMove function (Game start condition) with dx as 20 (+ve), dy as 0, and the previously set disallowedDirection previously is called over here.

In this way, we make the movement of the snake in a particular direction. Now let's have a look at the sagas that we have used, and how they handle the movement of the snake.

Let's create a file called saga/index.ts. This file will consist of all our sagas. This is not a rule, but in general, we create two sagas.

The first one is the saga which dispatches the actual actions to the store – let's call this worker saga. The second is the watcher saga which watches for any action that is being dispatched – let's call this watcher saga.

Now we need to create a watcher saga that will look out for the following actions: MOVE_RIGHT, MOVE_LEFT, MOVE_UP, MOVE_DOWN.

function* watcherSaga() {
    yield takeLatest(
      [MOVE_RIGHT, MOVE_LEFT, MOVE_UP, MOVE_DOWN],
      moveSaga
    ); 
}

This watcher saga will watch for the actions above and execute the moveSaga function which is a worker saga.

You will notice that we have used a new function named takeLatest. This function will call the worker saga and cancel any previous saga calls if any of the actions mentioned in the first argument are dispatched.

From the words of the redux-saga docs:

takeLatest(pattern, saga, ...args)

Forks a saga on each action dispatched to the Store that matches pattern. And automatically cancels any previous saga task started previously if it's still running.

• Each time an action is dispatched to the store. And if this action matches pattern, takeLatest starts a new saga task in the background. If a saga task was started previously (on the last action dispatched before the actual action), and if this task is still running, the task will be cancelled.
• pattern: String | Array | Function - for more information see docs for [take(pattern)](https://redux-saga.js.org/docs/api/#takepattern)
• saga: Function - a Generator function
• args: Array<any> - arguments to be passed to the started task. takeLatest will add the incoming action to the argument list (i.e. the action will be the last argument provided to saga)

Now let's create a worker saga called moveSaga which will actually dispatch the actions to the Redux store:

export function* moveSaga(params: {
    type: string;
    payload: ISnakeCoord;
  }): Generator<
    | PutEffect<{ type: string; payload: ISnakeCoord }>
    | PutEffect<{ type: string; payload: string }>
    | CallEffect<true>
  > {
    while (true) {
    //dispatches movement actions
     yield put({
           type: params.type.split("_")[1],
           payload: params.payload,
      }); 

      //Dispatches SET_DIS_DIRECTION action
      switch (params.type.split("_")[1]) {
        case RIGHT:
          yield put(setDisDirection(LEFT));
          break;

        case LEFT:
          yield put(setDisDirection(RIGHT));
          break;

        case UP:
          yield put(setDisDirection(DOWN));
          break;

        case DOWN:
          yield put(setDisDirection(UP));
          break;
      }
      yield delay(100);
    }
  }

The moveSaga worker saga performs the following functions:

1. It executes inside an infinite loop.
2. So once a direction is given – that is if the d key is pressed and MOVE_RIGHT action is dispatched – then it starts dispatching the same action until a new action (that is, direction) is given. This is handled by the below snippet:

yield put({
    type: params.type.split("_")[1],
    payload: params.payload,
});

3. Once the above action is dispatched we set the disallowed direction to the opposite direction which is taken care of by the action creator setDisDirection.

Now let's stitch these sagas into our sagas/index.ts file:

import {
    CallEffect,
    delay,
    put,
    PutEffect,
    takeLatest
} from "redux-saga/effects";
import {
    DOWN,
    ISnakeCoord,
    LEFT,
    MOVE_DOWN,
    MOVE_LEFT,
    MOVE_RIGHT,
    MOVE_UP, RIGHT,
    setDisDirection, UP
} from "../actions";

  export function* moveSaga(params: {
    type: string;
    payload: ISnakeCoord;
  }): Generator<
    | PutEffect<{ type: string; payload: ISnakeCoord }>
    | PutEffect<{ type: string; payload: string }>
    | CallEffect<true>
  > {
    while (true) {
      yield put({
        type: params.type.split("_")[1],
        payload: params.payload,
      });
      switch (params.type.split("_")[1]) {
        case RIGHT:
          yield put(setDisDirection(LEFT));
          break;

        case LEFT:
          yield put(setDisDirection(RIGHT));
          break;

        case UP:
          yield put(setDisDirection(DOWN));
          break;

        case DOWN:
          yield put(setDisDirection(UP));
          break;
      }
      yield delay(100);
    }
  }

  function* watcherSagas() {
    yield takeLatest(
      [MOVE_RIGHT, MOVE_LEFT, MOVE_UP, MOVE_DOWN],
      moveSaga
    );
  }

  export default watcherSagas;

Now let's update our CanvasBoard component to incorporate these changes.

//Importing necessary modules
import { useSelector } from "react-redux";
import { drawObject, generateRandomPosition } from "../utils";

export interface ICanvasBoard {
    height: number;
    width: number;
}

const CanvasBoard = ({ height, width }: ICanvasBoard) => {
    const canvasRef = useRef < HTMLCanvasElement | null > (null);
    const [context, setContext] = useState < CanvasRenderingContext2D | null > (null);
    const snake1 = useSelector((state: IGlobalState) => state.snake);
    const [pos, setPos] = useState < IObjectBody > (
        generateRandomPosition(width - 20, height - 20)
    );

    const moveSnake = useCallback(
        (dx = 0, dy = 0, ds: string) => {
            if (dx > 0 && dy === 0 && ds !== "RIGHT") {
                dispatch(makeMove(dx, dy, MOVE_RIGHT));
            }

            if (dx < 0 && dy === 0 && ds !== "LEFT") {
                dispatch(makeMove(dx, dy, MOVE_LEFT));
            }

            if (dx === 0 && dy < 0 && ds !== "UP") {
                dispatch(makeMove(dx, dy, MOVE_UP));
            }

            if (dx === 0 && dy > 0 && ds !== "DOWN") {
                dispatch(makeMove(dx, dy, MOVE_DOWN));
            }
        },
        [dispatch]
    );

    const handleKeyEvents = useCallback(
        (event: KeyboardEvent) => {
            if (disallowedDirection) {
                switch (event.key) {
                    case "w":
                        moveSnake(0, -20, disallowedDirection);
                        break;
                    case "s":
                        moveSnake(0, 20, disallowedDirection);
                        break;
                    case "a":
                        moveSnake(-20, 0, disallowedDirection);
                        break;
                    case "d":
                        event.preventDefault();
                        moveSnake(20, 0, disallowedDirection);
                        break;
                }
            } else {
                if (
                    disallowedDirection !== "LEFT" &&
                    disallowedDirection !== "UP" &&
                    disallowedDirection !== "DOWN" &&
                    event.key === "d"
                )
                    moveSnake(20, 0, disallowedDirection); //Move RIGHT at start
            }
        },
        [disallowedDirection, moveSnake]
    );
    useEffect(() => {
        //Draw on canvas each time
        setContext(canvasRef.current && canvasRef.current.getContext("2d")); //store in state variable
                    clearBoard(context);
        drawObject(context, snake1, "#91C483"); //Draws snake at the required position
    }, [context]);

    useEffect(() => {
        window.addEventListener("keypress", handleKeyEvents);

        return () => {
            window.removeEventListener("keypress", handleKeyEvents);
        };
    }, [disallowedDirection, handleKeyEvents]);

    return (
        <canvas
            style={{
                border: "3px solid black",
            }}
            height={height}
            width={width}
        />
    );
};

Once you've made these changes you can try moving the snake. And voilà! You will see the following output:

Moving snake across the board

Drawing the fruit at a random position

To draw a fruit at a random position on the board we will use the generateRandomPosition utility function. Let's have a look at this function:

function randomNumber(min: number, max: number) {
  let random = Math.random() * max;
  return random - (random % 20);
}
export const generateRandomPosition = (width: number, height: number) => {
  return {
    x: randomNumber(0, width),
    y: randomNumber(0, height),
  };
};

This is a function that will generate random x and y coordinates in multiples of 20. These coordinates will always be less than the width and height of the board. It accepts width and height as arguments.

Once we have this function we can use it to draw the fruit at a random position inside the board.

First, let's create a state variable pos that will initially consist of some random position.

const [pos, setPos] = useState<IObjectBody>(generateRandomPosition(width - 20, height - 20));

Then, we will draw the fruit via our drawObject function. After this we will slightly update our useEffect hook:

 useEffect(() => {
        //Draw on canvas each time
        setContext(canvasRef.current &&   canvasRef.current.getContext("2d")); //store in state variable

        clearBoard(context);

        drawObject(context, snake1, "#91C483"); //Draws snake at the required position

        drawObject(context, [pos], "#676FA3"); //Draws object randomly
    }, [context]);

Once we have made the changes our board will look like below:

Snake and fruit drawn on the board

Score calculator

The game score is calculated based on how many fruits the snake has consumed without colliding with itself or with the boundary of the box. If the snake consumes the fruit then the size of the snake increases. If it collides with the edge of the box, then the game is over.

Now that we know what our criteria are for calculating the score, let's have a look on how we calculate the reward.

Calculating the reward

The reward after the snake consumes the fruit is as follows:

1. Increase the size of the snake.
2. Increase the score.
3. Place the new fruit at a different random location.

If the snake consumes the fruit, then we must increase the size of the snake. This is a really simple task, we can just append the new x and y coordinates which are less than 20 from the last element of the snake global state array. For example, if the snake has the following coordinates:

{
snake: [
    { x: 580, y: 300 },
    { x: 560, y: 300 },
    { x: 540, y: 300 },
    { x: 520, y: 300 },
    { x: 500, y: 300 },
  ],
}

We should simply append the following object into the snake array: { x: 480, y: 280 }

In this way, we increase the size of the snake as well as add the new part/block at the end of it. For this to be implemented via Redux and redux-saga, we will need the following action and action creator:

export const INCREMENT_SCORE = "INCREMENT_SCORE"; //action

export const increaseSnake = () => ({  //action creator
    type: INCREASE_SNAKE
  });

We will also update our gameReducer to accommodate these changes. We will add the following case:

case INCREASE_SNAKE:
      const snakeLen = state.snake.length;
      return {
        ...state,
        snake: [
          ...state.snake,
          {
            x: state.snake[snakeLen - 1].x - 20,
            y: state.snake[snakeLen - 1].y - 20,
          },
        ],
      };

In our CanvasBoard component, we will first introduce a state variable called isConsumed. This variable will check if the fruit is consumed or not.

const [isConsumed, setIsConsumed] = useState<boolean>(false);

In our useEffect hook where we are drawing our snake and the fruit just below that, we will add the following condition:

//When the object is consumed
    if (snake1[0].x === pos?.x && snake1[0].y === pos?.y) {
      setIsConsumed(true);
    }

The above condition will check if the head of the snake snake[0] is equal to the pos, or the position of the fruit. If it is true, then it will set the isConsumed state variable to true.

Once the fruit is consumed, we need to increase the size of the snake. We can do this easily via another useEffect. Let's create another useEffect and call the action creator increaseSnake:

//useEffect2
useEffect(() => {
    if (isConsumed) {
      //Increase snake size when object is consumed successfully
      dispatch(increaseSnake());
    }
  }, [isConsumed]);

Now that we have increased the size of the snake, let's take a look at how we can update the score and generate a new fruit at another random position.

To generate a new fruit at another random position, we update the pos state variable which will re-run the useEffect1 and draw the object at pos. We should update our useEffect1 with a new dependency of pos and update useEffect2 as follows:

useEffect(() => {
    //Generate new object
    if (isConsumed) {
      const posi = generateRandomPosition(width - 20, height - 20);
      setPos(posi);
      setIsConsumed(false);

      //Increase snake size when object is consumed successfully
      dispatch(increaseSnake());
    }
  }, [isConsumed, pos, height, width, dispatch]);

One last thing left to do in this reward system is to update the score each time the snake eats the fruit. To do this follow the below steps:

1. Introduce a new global state variable called score. Update our global state as below in the reducers/index.ts file:

export interface IGlobalState {
  snake: ISnakeCoord[] | [];
  disallowedDirection: string;
  score: number;
}

const globalState: IGlobalState = {
  snake: [
    { x: 580, y: 300 },
    { x: 560, y: 300 },
    { x: 540, y: 300 },
    { x: 520, y: 300 },
    { x: 500, y: 300 },
  ],
  disallowedDirection: "",
  score: 0,
};

2. Create the following action and action creator in our actions/index.ts file:

export const INCREMENT_SCORE = "INCREMENT_SCORE"; //action

//action creator:
export const scoreUpdates = (type: string) => ({
  type
});

3. Next, update our reducer to handle the INCREMENT_SCORE action. This will simply increment the global state score by one.

case INCREMENT_SCORE:
      return {
        ...state,
        score: state.score + 1,
      };

4. Then we update our score state, dispatching the INCREMENT_SCORE action each time snake catches the fruit. For this we can update our useEffect2 as follows:

useEffect(() => {
    //Generate new object
    if (isConsumed) {
      const posi = generateRandomPosition(width - 20, height - 20);
      setPos(posi);
      setIsConsumed(false);

      //Increase snake size when object is consumed successfully
      dispatch(increaseSnake());

      //Increment the score
      dispatch(scoreUpdates(INCREMENT_SCORE));
    }
  }, [isConsumed, pos, height, width, dispatch]);

5. Finally, we create a component called ScoreCard. This will display the player’s current score. We will store this in the file components/ScoreCard.tsx.

import { Heading } from "@chakra-ui/react";
import { useSelector } from "react-redux";
import { IGlobalState } from "../store/reducers";

const ScoreCard = () => {
    const score = useSelector((state: IGlobalState) => state.score);
    return (
        <Heading as="h2" size="md" mt={5} mb={5}>Current Score: {score}</Heading>
    );
}

export default ScoreCard;

After this we should also add the ScoreCard component into the App.tsx file to display it on our page.

import { ChakraProvider, Container, Heading } from "@chakra-ui/react";
import { Provider } from "react-redux";
import CanvasBoard from "./components/CanvasBoard";
import ScoreCard from "./components/ScoreCard";
import store from "./store";

const App = () => {
  return (
    <Provider store={store}>
      <ChakraProvider>
        <Container maxW="container.lg" centerContent>
          <Heading as="h1" size="xl">SNAKE GAME</Heading>
          <ScoreCard />
          <CanvasBoard height={600} width={1000} />
        </Container>
      </ChakraProvider>
    </Provider>
  );
};

export default App;

Once everything is in place, our snake will have a complete reward system that increases the size of the snake to update the score.

Player playing snake with updating score and snake length.

Collision detection

In this section, we are going to take a look at how we implement collision detection for our Snake game.

In our Snake game, if a collision is detected, then the game is over – that is, the game stops. There are two conditions for collisions to happen:

1. Snake collides with the boundaries of the box, or
2. Snake collides with itself.

Let's take a look at the first condition. Suppose the head of the snake touches the boundaries of the box. In that case we will immediately stop the game.

For this to be incorporated into our game we will need to do as follows:

1. Create an action and an action creator as below:

export const STOP_GAME = "STOP_GAME"; //action

//action creator
export const stopGame = () => ({
  type: STOP_GAME
});

2. We need to update our sagas/index.ts file as well. We are going to make sure that saga stops dispatching actions once the STOP_GAME action is encountered.

export function* moveSaga(params: {
  type: string;
  payload: ISnakeCoord;
}): Generator<
  | PutEffect<{ type: string; payload: ISnakeCoord }>
  | PutEffect<{ type: string; payload: string }>
  | CallEffect<true>
> {
  while (params.type !== STOP_GAME) {
    yield put({
      type: params.type.split("_")[1],
      payload: params.payload,
    });
    switch (params.type.split("_")[1]) {
      case RIGHT:
        yield put(setDisDirection(LEFT));
        break;

      case LEFT:
        yield put(setDisDirection(RIGHT));
        break;

      case UP:
        yield put(setDisDirection(DOWN));
        break;

      case DOWN:
        yield put(setDisDirection(UP));
        break;
    }
    yield delay(100);
  }
}

function* watcherSagas() {
  yield takeLatest(
    [MOVE_RIGHT, MOVE_LEFT, MOVE_UP, MOVE_DOWN, STOP_GAME],
    moveSaga
  );
}

3. Finally we need to update our useEffect1 by adding the following condition:

if ( //Checks if the snake head is out of the boundries of the obox
      snake1[0].x >= width ||
      snake1[0].x <= 0 ||
      snake1[0].y <= 0 ||
      snake1[0].y >= height
    ) {
      setGameEnded(true);
      dispatch(stopGame());
      window.removeEventListener("keypress", handleKeyEvents);
    }

We are also removing the event listener handleKeyEvents. This will make sure that once the game is over the player cannot move the snake.

Finally, let's have a look at how we can detect the self-collision of the snake. We are going to use a utility function called hasSnakeCollided. It accepts two parameters: the first is the snake array, and the second is the head of the snake. If the head of the snake touches any parts of itself then it returns true or else it returns false.

The hasSnakeCollided function will look like below:

export const hasSnakeCollided = (
  snake: IObjectBody[],
  currentHeadPos: IObjectBody
) => {
  let flag = false;
  snake.forEach((pos: IObjectBody, index: number) => {
    if (
      pos.x === currentHeadPos.x &&
      pos.y === currentHeadPos.y &&
      index !== 0
    ) {
      flag = true;
    }
  });

  return flag;
};

We might slightly need to update our useEffect1 by updating the collision detection condition like this:

if (  
      //Checks if the snake has collided with itself 
      hasSnakeCollided(snake1, snake1[0]) ||

      //Checks if the snake head is out of the boundries of the obox
      snake1[0].x >= width ||
      snake1[0].x <= 0 ||
      snake1[0].y <= 0 ||
      snake1[0].y >= height
    ) {
      setGameEnded(true);
      dispatch(stopGame());
      window.removeEventListener("keypress", handleKeyEvents);
    }

Our useEffect1 will finally look like below:

//useEffect1
useEffect(() => {
    //Draw on canvas each time
    setContext(canvasRef.current && canvasRef.current.getContext("2d"));
    clearBoard(context);
    drawObject(context, snake1, "#91C483");
    drawObject(context, [pos], "#676FA3"); //Draws object randomly

    //When the object is consumed
    if (snake1[0].x === pos?.x && snake1[0].y === pos?.y) {
      setIsConsumed(true);
    }

    if (
      hasSnakeCollided(snake1, snake1[0]) ||
      snake1[0].x >= width ||
      snake1[0].x <= 0 ||
      snake1[0].y <= 0 ||
      snake1[0].y >= height
    ) {
      setGameEnded(true);
      dispatch(stopGame());
      window.removeEventListener("keypress", handleKeyEvents);
    } else setGameEnded(false);
  }, [context, pos, snake1, height, width, dispatch, handleKeyEvents]);

Our game will look like below once we add the collision detection system:

Collision detection

Instruction component

We are in the end game now! Our final component will be the Instruction component. It will consist of instructions about the game like initial game condition, keys to use, and a reset button.

Let's start by creating a file called components/Instructions.tsx. Place the below code in this file:

import { Box, Button, Flex, Heading, Kbd } from "@chakra-ui/react";

export interface IInstructionProps {
  resetBoard: () => void;
}
const Instruction = ({ resetBoard }: IInstructionProps) => (
  <Box mt={3}>
    <Heading as="h6" size="lg">
      How to Play
    </Heading>
    <Heading as="h5" size="sm" mt={1}>
    NOTE: Start the game by pressing <Kbd>d</Kbd>
    </Heading>
    <Flex flexDirection="row" mt={3}>
      <Flex flexDirection={"column"}>
        <span>
          <Kbd>w</Kbd> Move Up
        </span>
        <span>
          <Kbd>a</Kbd> Move Left
        </span>
        <span>
          <Kbd>s</Kbd> Move Down
        </span>
        <span>
          <Kbd>d</Kbd> Move Right
        </span>
      </Flex>
      <Flex flexDirection="column">
        <Button onClick={() => resetBoard()}>Reset game</Button>
      </Flex>
    </Flex>
  </Box>
);

export default Instruction;

The Instruction component will accept resetBoard as a prop which is a function that will help the user when the game is over or when they want to reset the game.

Before we dive into the resetBoard function we need to make the following updates in our Redux store and saga:

1. Add the following action and action creator in the actions/index.ts file:

export const RESET_SCORE = "RESET_SCORE"; //action
export const RESET = "RESET"; //action

//Action creator:
export const resetGame = () => ({
  type: RESET
});

2. Then add the following condition into our sagas/index.ts. We are going to make sure that saga discontinues to dispatch actions once the RESET and the STOP_GAME actions are encountered.

export function* moveSaga(params: {
  type: string;
  payload: ISnakeCoord;
}): Generator<
  | PutEffect<{ type: string; payload: ISnakeCoord }>
  | PutEffect<{ type: string; payload: string }>
  | CallEffect<true>
> {
  while (params.type !== RESET && params.type !== STOP_GAME) {
    yield put({
      type: params.type.split("_")[1],
      payload: params.payload,
    });
    switch (params.type.split("_")[1]) {
      case RIGHT:
        yield put(setDisDirection(LEFT));
        break;

      case LEFT:
        yield put(setDisDirection(RIGHT));
        break;

      case UP:
        yield put(setDisDirection(DOWN));
        break;

      case DOWN:
        yield put(setDisDirection(UP));
        break;
    }
    yield delay(100);
  }
}

function* watcherSagas() {
  yield takeLatest(
    [MOVE_RIGHT, MOVE_LEFT, MOVE_UP, MOVE_DOWN, RESET, STOP_GAME],
    moveSaga
  );
}

3. Finally, we update our reducers/index.ts file for the RESET_SCORE case as follows:

case RESET_SCORE:
      return { ...state, score: 0 };

Once our sagas and reducers are updated we can take a look at what operations the resetBoard callback will perform.

The resetBoard function performs the following operations:

1. Removes the event listener handleKeyEvents
2. dispatches the actions necessary for resetting the game.
3. Dispatches the action to reset the score.
4. Clears the canvas.
5. Draws the snake again at its initial position
6. Draws the fruit at a new random position.
7. Finally, adds the event listener handleKeyEvents for the keypress event.

Below is how our resetBoard function will look:

const resetBoard = useCallback(() => {
    window.removeEventListener("keypress", handleKeyEvents);
    dispatch(resetGame());
    dispatch(scoreUpdates(RESET_SCORE));
    clearBoard(context);
    drawObject(context, snake1, "#91C483");
    drawObject(
      context,
      [generateRandomPosition(width - 20, height - 20)],
      "#676FA3"
    ); //Draws object randomly
    window.addEventListener("keypress", handleKeyEvents);
  }, [context, dispatch, handleKeyEvents, height, snake1, width]);

You should place this function inside the CanvasBoard component and pass the resetBoard function as a prop to the Instruction function as below:

<>
      <canvas
        ref={canvasRef}
        style={{
          border: `3px solid ${gameEnded ? "red" : "black"}`,
        }}
        width={width}
        height={height}
      />
      <Instruction resetBoard={resetBoard} />
    </>

Once this is placed we will have the Instruction component set up like below:

Instructions with reset button

Final Game

If you have followed along up to this point, then congrats! You have successfully created a fun Snake game with React, Redux and redux-sagas. Once all of these things are connected your game will look like below:

The complete snake game

Summary

So this is how you can build a Snake game from scratch. You can find the entire source code for the game in the below repository:

https://github.com/keyurparalkar/snake-game

If you liked the idea of building your own Snake game from scratch then you can take it up a notch by building these enhancements:

• Build the snake game with three.js
• Add an online score board

Thank you for reading!

Follow me on Twitter, GitHub, and LinkedIn.

According to True Education Partnerships,

Gamification in learning involves using game-based elements such as point scoring, peer competition, team work, and score tables to drive engagement, help students assimilate new information and test their knowledge.

I have curated a list of 12 coding games for beginners.

Here is the complete list. Once you find a website that interests you, click that link and it will jump you down to a more detailed description of that website.

1. CodinGame
2. CSS Diner
3. Flexbox Froggy
4. Flexbox Defense
5. Grid Garden
6. CodeCombat
7. Scratch
8. Tynker
9. SQL Murder Mystery
10. Untrusted
11. Elevator Saga
12. CheckiO

CodinGame

CodinGame is a site that helps you work on problem solving skills and learn programming basics through a turn-based game.

This platform supports over 25 different programming languages and gives players the opportunity to practice, learn, and compete in coding contests.

Once you create an account, you can get started with the beginner level onboarding section. You will be introduced to standard programming concepts and solve mini challenges.

CSS Diner

In CSS Diner, you can practice the basics of CSS through a series of 32 challenges. This is a good way to get more familiar with the language and have fun learning it.

The first few challenges are short and focus on working with classes and ids. But as you progress through the levels, you will be introduced to Pseudo-selectors, First of Type Selector, Last of Type Selector, and the Universal Selector.

Flexbox Froggy

In Flexbox Froggy, you will learn CSS Flexbox by placing the frogs on the correct lillypads. By the time you finish level 24, you should feel comfortable using Flexbox in your next project.

Each challenge provides a description on the Flexbox properties. The first few challenges start off easy but as you progress in the game things get more complicated.

Flexbox Defense

Flexbox Defense is a tower defense game that helps you strengthen your CSS skills. Position the towers to keep out your enemies using CSS Flexbox.

The challenges will provide you with definitions of the Flexbox properties. Once you write your code, press the Start Wave button and see if you were successful in stopping your enemies.

Grid Garden

Learn CSS Grid by going through 28 levels of Grid Garden. Some familiarity with CSS Grid is encouraged but not required for getting started with the game.

Each challenge provides a description on the CSS Grid properties. The first few challenges start off easy but as you progress in the game things get more complicated.

CodeCombat

CodeCombat works well for both kids and adult learners. You can create a free account and learn the fundamentals of programming like loops, functions, conditionals, and variables.

You can choose which programming language to start with and work your way through the games.

You also have the option to upgrade to the premium account if you are interested in having access to more levels.

Scratch

MIT's Scratch is a block based programming language where you can learn about events, conditionals, variables, and more by building your own games and animations.

Choose from dozens of sprites, sounds and backgrounds to code your own creations and start understanding programming basics.

Scratch is also used during the first week of Harvard's CS50: Introduction to Computer Science course.

Tynker

Tynker is a site where you can build projects and play games using HTML, CSS, JavaScript, Python, and Java. They have an extensive list of projects, algorithms and data structure challenges.

You can build these projects in the online editor and share your creations within the community. This site is aimed at kids between the ages of 5-18.

SQL Murder Mystery

SQL Murder Mystery is great for both beginners and experienced SQL developers. Strengthen your SQL and problem solving skills by trying to track down the killer in this murder mystery.

The game uses SQLite and you will first have to get acquainted with the database structure before starting the game.

If you are new to SQL, there is a detailed walk through for beginners. Otherwise, if you are an experienced SQL user then you can dive straight into the game.

Untrusted

Untrusted is an adventure game where you can test your JavaScript and problem solving skills. Help guide Dr. Eval through a series of levels by solving JavaScript challenges.

If you are brand new to JavaScript then this game might be a little advanced for you. But if you have spent some time programming in JavaScript then the challenges will be doable.

Elevator Saga

Elevator Saga is a JavaScript game where you will go through a series of challenges trying to transport people in elevators in the most efficient way possible within the time given.

Once you modify the code, you can test the efficiency of your solution by clicking the start button in the top right hand corner. When the program is running, you can check the stats to see if you passed the challenge or not.

CheckiO

CheckiO is a strategy game where you can learn TypeScript or Python through a series of challenges. Once you create a free account, you will start off with the beginner challenges and work your way through to the advanced ones.

The game will give you access to hints and other players' solutions if you need help. You will solve each of the challenges in the online editor and move onto the next mission when the task is solved.

When you land on the page, right above the search box, you'll see Google's logo. On many occassions the logo will be different and accompanied by what's called a Doodle.

These Doodles range from small, simple and temporary alterations to the traditional logo. But more often that not, they are very creative and artistic expressions.

They highlight world issues, major historical events, worldwide holidays, local celebrations, anniversaries and important figures' brithdays (including pioneers, artists, and scientists) along with their contributions to society.

When you click on the Doodle animation you can find more information about that specific topic and a little game or interaction sometimes sometimes accompanies the doodle.

The First Google Doodle

The first doodle was created when Google co-founders Larry Page and Sergey Brin attended the annual Burning Man Festival in the Nevada desert in the United States on 30 August 1998.

They put a stick figure icon, resembling the Burning Man logo, behind the second "O" as an "Out Of Office" message to let users know of their absence in a fun and creative way.

Google was very young at the time – it had only been a couple of years since the search engine had been built by these two Stanford students. And this was just less than a week before it would be offically incorporated as a company.

You can also see that the logo was different, with an exclamation mark at the end.

The Development of Google Doodles

Since then, this new idea of altering the logo when celebrating notable events was born, and the Doodles progressed.

Nearly two years later, Page and Brin asked Dennis Hwang – an intern at the time – to create a doodle in honor of Bastille Day, on July 14 2000. It was very well received and Dennis Hwang was appointed Chief Doodler.

Doodles started to appear more regularly on the homepage.

Since then, Google has a whole dedicated team of talented illustrators (called doodlers) responsible for the doodle that appears on Google's homepage for the entire globe.

The early doodles were fairly simple. When you hovered over the doodle, a little pop up text would appear noting what was being commemorated.

For Halloween in 2000, guest artist Lorie Loeb created the very first animated doodle. It featured two jack-o-lanterns in place of the "O"’s and a spider was dangling from the "L".

Another notable tech-related, nostalgic doodle was that of March 12 2019, where Google commemorated the 30th anniversary of the World Wide Web.

You can view a historical archive of all the Google Doodles that have appeared on the homepage, letting you relive any Doodle and discover new ones you may not have seen already.

The First Google Doodle Game

The doodle technology kept on improving, and on May 21st 2010 Google released its first interactive game – the first ever playable Doodle Google game.

This release celebrated the 30th anniverary of one of the most popular and classic arcade games, Pac Man, which was released in 1980.

It was an immense development for Google and it must have brightend many peoples' days by bringing back such a fun and addictive throwback game. It was estimated that over 1 billion people played the game in the first three days of its release.

The PacMan doodle game brings up 8-bit nostalgic memories as it uses the same graphics, and the same original colors, sounds, and iconic characters. It even incudes the same original game logic and bugs (!).

If you want to take a trip down memory lane, or be introduced to the game for the first time, you can play it here.

Just press "Insert Coin" and use the arrow keys on your keyboard. You are a yellow hero aiming to eat all the dots without getting caught by ghosts of different colors.

Be prepared to spend one too many hours on this one.

How to Play Doodle Google Games

Since then there have been many more fun and interactive games and puzzles.

The doodles and games usually stay up for one day to commemorate a specific event. But Google archives all its old doodles and doodle games on the dedicated archive page instead of just getting rid of them.

Thanks to this, you can play any of the games that have been featured on the search engine's homepage.

Playing them is easy and fuss free.

They are all web based and can be played on both desktop and mobile without needing to download anything or set up a console. You don't need any equipment – just a browser and an internet connection.

Click on the links to go to the page for the specific game and then click to start the game.

In most cases you'll use your mouse or trackpad and keyboard. If you're playing from a mobile you'll be swipping or tapping.

Popular Doodle Google Games

Below is a list of some of the most well known and popular doodle games, grouped together based on different categories.

Doodle brain teaser games

Rubik's Cube

The Rubik's cube appeared on the homepage on May 19, 2014 and is one of the biggest and most fascinating mental challenges.

The colors move horizontally, but you can move its pieces by clicking anywhere on the cube to turn it on all its sides.

Crossword puzzles

On December 21st 2013, Google came out with a tribute to crosswords to commemorate 100 years of crossword puzzles.

With the help of Merl Reagle, one of the best and most well known crossword instructors, Google created their own version of a crossword with clues. It also shared bits of puzzle history throughout.

Doodle coding games

Coding for carrots

Coding for carrots introduces childern (or you!) to the world of programming by connecting blocks that represent coding concepts. This helps guide a rabbit across 6 levels to get to its favorite food – a carrot – and collect it.

The game was released on 4 December 2017 during Computer Science Education week in collaboration with MIT to celebrate 50 years of Kids Coding and of coding languages for kids. It's based on the Scratch programming language.

Doodle games for sports fans

Cricket

Cricket was introduced to celebrate the 2017 ICC Champions Trophy and you play cricket as an animated cricket.

Just click on the bat to swing it when you see the ball coming towards you and want to hit it to score. It's a clever re-creation of the sport.

Baseball

Baseball was introduced in honor of 4th of July, US Independence day, in 2019. The players are classic American snacks like hot dogs, fries, and ketchup.

Click to swing the bat and if you're like I am, be prepared to hear "You're Out" too many times (otherwise you'll see plenty of fireworks).

Basketball

Basketball came out in 2012, honoring the 2012 Olympic Summer games with this interactive basketball game. You try to make as many baskets as you can in 24 seconds.

Besides this game, for that period Google released three other separate interactive sports games, like Soccer. With this one you're a goal keeper, using the space key to stop the incoming ball from reaching the net and the arrow keys to change your position.

2020 Tokyo Olympics

In celebration of the 2020 Tokyo Olympics,Google released its most ambitious, elaborate, and complex game to date – a full on anime sports game called the Doodle Champion Island Games.

It's a homage to retro 16-bit Japanese video games, with 7 mini Olympic game sporting event themes to choose from (including table tennis, skateboarding, and artistic swimming among others). It's the largest game Google has released.

You play as a Calico ninja warrior cat named Lucky that arrives on the island where the festival is underway. You can choose from one of 4 teams - the Blue, Red, Yellow, or Green team - represented by Ushi, Karasu, Inari, or Kappa.

To play, use the arrow keys and space bar and pay tribute by celebrating Japanese history, culture, and sports throughtout the game. It was made in partnership with Japanese animation studio Studio 4°C.

Doodle games for music lovers

Celebrating Oskar Fischinger

Fischinger was created on 17 June 2017 to celebrate Oskar Fischinger's 117th birthday.

To honor the filmmaker and visual artist, Google released an interactive design with a visual music composition tool, letting users click and create their own visual pieces of music with the wide variety of settings you can change.

Celebrating the birth of Hip Hop

Hip Hop was released to commemorate the 44th anniversary of the birth of hip-hop, on 11th August 2017.

With the crossfader you can mix legendary beats together, change the volume and intensity of playback speed, and pick tracks. The classic DJ interactive turntable will let you cut and scratch tracks and relive hip-hop history.

The graffiti was made by artist Cey Adams, and it's narrated by hip-hop icon Fab Five Freddy. It pays tribute to Kool Herc and Coke La Rock, the two founding fathers of hip hop.

Rockmore

Rockmore simulates the experience of the Theremin. This is an electronic musical instrument that works without physical contact – only by gesture controls.

The game celebrates the anniversary of Clara Rockmore’s 105th birthday, the inventor and the instrument's most well known performer, on 9th March 2016.

It will let you create music and experiment with the different settings and replicate different notes. Move your cursor or mouse over the notes on the screen to create music using a virtual Theremin.

Doodle games for creatives

Quick draw

Quick draw! is a game that got its own website. You are given instructions on the screen about what to draw and a 20 second timeframe to do so. Google's neural network then makes guesses and tells you what your drawing resembles.

The game is built with Machine Learning and is one of the most popular Doodle games.

Doodle games for science-fiction enthusiasts

Doctor Who

The Doctor Who doodle game, released on 23 November 2013, was created to honor the 50th anniversary of the classic and popular British television show, Doctor Who.

It's a simple but impressive adventure puzzle game, featuring all of the 13 doctors at the time it was made.

The goal is to retrieve all of the 6 letters from Google logo that the Daleks stole from the doctors, going through the 6 levels of the game.

Doodle food games

Scoville was released on 22nd January 2016 to celebrate Wilbur Scoville’s 151st birthday.

The Scoville Scale is a system that measures how hot a pepper is. In this game, you're an ice cream fighting against spicy peppers by throwing scoops at them. Peppers start progressively getting hotter each time.

Doodle games for people who love Halloween

The Magic Cat Academy

The Magic Cat Academy celebrated Halloween in 2016 and follows a cat named Momo who wants to restore peace at the Magic Cat Academy where she's a student so she can rescue the school.

The muse for this game was a black cat that belongs to the Doodler who built the game, Juliana Chen.

Momo has to go through 5 levels in her school – the library, cafeteria, classroom, gym, and building rooftop. And along the way she has to swipe her wand to trace symbols above the heads of the ghosts that appear! This way, Momo casts spells and won't get her spellbook taken away from her by the ghosts that are lurking.

Use your keypad to swipe above the ghosts's heads, turning them into thin air.

Doodle games for those who enjoy card games

Loteria

Loteria is a traditional Mexican card game. You can start a match with your friends or with random people from all around the globe.

It was released on 9th December 2019, celebrating this traditional game with a virtual version. There is a tutorial before your first trial round if you've never played Lotería before.

Conclusion

I hope you enjoyed this write-up of some of Google's most popular Doodle Games for you to try.

There are many more available on the dedicated archive page, so go have a look and see what interests you.

Thanks for reading!

Copyright: All images belong to Google

In this article I am going to show you how to build a snake game with JavaScript.

A snake game is a simple game where a snake moves around a box trying to eat an apple. Once it successfully eats the apple, the length of the snake increases and the movement becomes faster.

Then the game is over when the snake runs into itself or any of the four walls of the box.

Alright, let's start with the HTML and CSS (the skeleton for our game).

HTML

<h1>Nokia 3310 snake</h1>
<div class="scoreDisplay"></div>
<div class="grid"></div>
<div class="button">
  <button class="top">top</button>
  <button class="bottom">bottom</button>
  <button class="left">left</button>
  <button class="right">right</button>
</div>
<div class="popup">
  <button class="playAgain">play Again</button>
</div>

The HTML above is pretty basic.

• We have a div of class scoreDisplay that will display our scores.
• There's a div of class grid that will house the game (this is going to be a 10 by 10 grid)
• The class button basically contains a button for users playing the game on a phone (we will automate it with the keyboard for desktop user).
• And the popup class will hold our replay button.

Now let's add some styling with CSS.

CSS

body {
  background: rgb(212, 211, 211);
}

.grid {
  width: 200px;
  height: 200px;
  border: 1px solid red;
  margin: 0 auto;
  display: flex;
  flex-wrap: wrap;
}

.grid div {
  width: 20px;
  height: 20px;
  /*border:1px black solid;
box-sizing:border-box*/
}

.snake {
  background: blue;
}

.apple {
  background: yellow;
  border-radius: 20px;
}

.popup {
  background: rgb(32, 31, 31);
  width: 100px;
  height: 100px;
  position: fixed;
  top: 100px;
  left: 100px;
  display: flex;
  justify-content: center;
  align-items: center;
}

In the CSS, the grid which is the gameboard has a set dimension and a display of flex. This allows the contents (div) of this grid to line up in a horizontal manner as if they were inline elements instead of the normal block display which they possess.

The flex wrap property simply moves the divs to the next line, preventing them from going past the set dimension of their parent element (grid).

We will be dynamically creating the game board contents from JS but we can give a width and height here (with the .grid div). I included the comments here to help you actually see the divs, so as time goes on we will uncomment the code.

The snake and Apple classes are to show us where the snake and bonus is on the game, while the popup class is a fixed div that houses the replay div.

At this point, you should have something like this:

Structure with HTML and CSS

Now we're ready for the JavaScript.

JavaScript

The first thing we need to do is define our variables:

let grid = document.querySelector(".grid");
let popup = document.querySelector(".popup");
let playAgain = document.querySelector(".playAgain");
let scoreDisplay = document.querySelector(".scoreDisplay");
let left = document.querySelector(".left");
let bottom = document.querySelector(".bottom");
let right = document.querySelector(".right");
let up = document.querySelector(".top");
let width = 10;
let currentIndex = 0;
let appleIndex = 0;
let currentSnake = [2, 1, 0];
let direction = 1;
let score = 0;
let speed = 0.8;
let intervalTime = 0;
let interval = 0;

The variable width is exactly what it is (the width of the grid, that is 10). Other variables will make more sense as we go on – but believe it or not our snake is actually an array called currentSnake.

Now let's start with the functions:

document.addEventListener("DOMContentLoaded", function () {
  document.addEventListener("keyup", control);
  createBoard();
  startGame();
  playAgain.addEventListener("click", replay);
});

There is an eventListener on the document object called DomContentLoaded and this event is fired off immediately once the HTML content is loaded on our screen.

Once this happens, we set an eventListener on the document to watch for clicks on the keyboard (more on this later). After that, we want to create the gameBoard, start the game, and watch out for clicks on our replay button.

The createBoard function

function createBoard() {
  popup.style.display = "none";
  for (let i = 0; i < 100; i++) {
    let div = document.createElement("div");
    grid.appendChild(div);
  }
}

Like I said earlier, this is a 10 by 10 grid, meaning we are going to need 100 divs. So from above, we close the div popup and we loop to 100 every time we create a new div and append it to the grid (gameboard).

This will immediately add some of the styling we created from above (the .grid div). You can uncomment the CSS styles and you will see the divs created (uncomment them back).

The startGame function

function startGame() {
  let squares = document.querySelectorAll(".grid div");
  randomApple(squares);
  //random apple
  direction = 1;
  scoreDisplay.innerHTML = score;
  intervalTime = 1000;
  currentSnake = [2, 1, 0];
  currentIndex = 0;
  currentSnake.forEach((index) => squares[index].classList.add("snake"));
  interval = setInterval(moveOutcome, intervalTime);
}

The startGame function first gets all the divs (since we are creating the divs at runtime, we can not get them at the top of the code).

Next we select a spot for our apple. We will do that below in the randomApple function. The direction refers to where the snake is headed – 1 for right, -1 for left, and so on.

intervalTime sets the time it takes for the snake to move around, while currentSnake defines where exactly on the grid the snake will be (note that the snake is basically a couple of divs given a particular type of color).

To display our snake on the screen, we will loop over currentSnake with forEach. With each value we get, we will use it with squares. Remember that we accessed the grid divs with querySelectorAll, and we can then access them like an array, that is using numbers. In our case, these are the values of currentSnake.

After this, we simply append a setInterval call (with function move Outcome and a time of intervalTime, which we set above) to the variable interval. This is so that we can easily call clearInterval on that variable.

The moveOutcome runs every 1000ms (1s) and basically defines what happens when you move the snake.

The moveOutcome function

function moveOutcome() {
  let squares = document.querySelectorAll(".grid div");
  if (checkForHits(squares)) {
    alert("you hit something");
    popup.style.display = "flex";
    return clearInterval(interval);
  } else {
    moveSnake(squares);
  }
}

So like the startGame function above, we first get all the grid divs, and then we check if the checkForHits function returns true.

If it does, this means we have hit something and then it displays the replay button and it clears the interval. If it returns false, this means we did not hit anything and we move the snake with the moveSnake function.

So basically, every 1sec the game either comes to an end if checkForHits is true or we move the snake a step forward if checkForHits is false. I will talk about the moveSnake function first.

The moveSnake function

function moveSnake(squares) {
  let tail = currentSnake.pop();
  squares[tail].classList.remove("snake");
  currentSnake.unshift(currentSnake[0] + direction);
  // movement ends here
  eatApple(squares, tail);
  squares[currentSnake[0]].classList.add("snake");
}

The moveSnake function receives an argument called squares so that we don't have to get the .grid div again in this function.

The first thing we need to do is remove the last element of the currentSnake array via pop (this is the tail and the first element is always the head). Basically the snake moves a step forward leaving the previous position it was in. After this we simply add a new value to the beginning of the array with unShift.

Let's assume that our snake just started moving and is facing to the right (that is, direction = 1). That direction will be added to the currentSnake's head and the sum will be pushed as the new snakeHead.

For example, if the snake was in position [2,1,0], we remove the last element leaving it at position [2,1]. Then we take the head which is 2 and add the direction which is 1 and make this value the new value [3,2,1] which moves our snake a step forward to the right after one second.

If we want to move the snake downwards, the direction will be set to the width (which is 10) and added to the first element (that is 12 and pushed) [12,2,1].

After that we simply check if the snake has eaten an apple and display the new snakehead on the DOM.

The checkForHits function

function checkForHits(squares) {
  if (
    (currentSnake[0] + width >= width * width && direction === width) ||
    (currentSnake[0] % width === width - 1 && direction === 1) ||
    (currentSnake[0] % width === 0 && direction === -1) ||
    (currentSnake[0] - width <= 0 && direction === -width) ||
    squares[currentSnake[0] + direction].classList.contains("snake")
  ) {
    return true;
  } else {
    return false;
  }
}

The checkForHits function has an if statement. Depending on the condition defined, it could either return true (meaning we hit something) or false.

The first condition is if currentSnake [0] (the head of the snake) + width (10) is equal to the total area of the width (that is, width*width = 100) and the direction is equal to the width.

So basically let's assume that the snake's head is at position 97 which is the last layer of our grid. If you were to add 10 to 97 (= 107), that is greater than the whole grid which is 100. If the direction of the snake is still headed downwards, then the snake has hit the bottom border.

If the snake was at 97 , 97+10 =107, but the player was able to change the direction to, say, 1 (like, they pressed the left key), then it would not hit anything.

Or (||) if the remainder when the head of the snake divided by the width = width-1 (for example, 9) and the direction is 1. Every last div on the right hand side has a value of 9, 19, 29 and so on. So basically it will always remain 9 when you divide by 10.

If the head of our snake is at position 39 and the direction is still 1 (that is, the snake is still moving to the wall), then it has hit something (the right wall).

Every other condition is pretty much the exact opposite of the two above. The final condition allows that if the snake head is headed to a place that already contains a class snake, that simply means the snake is biting itself.

So...if any of the conditions above are true, the snake has hit something and true will be returned (else false). And if that's the case, the game is over. But if it is false, move the snake a step forward with moveSnake.

The eatApple function

function eatApple(squares, tail) {
  if (squares[currentSnake[0]].classList.contains("apple")) {
    squares[currentSnake[0]].classList.remove("apple");
    squares[tail].classList.add("snake");
    currentSnake.push(tail);
    randomApple(squares);
    score++;
    scoreDisplay.textContent = score;
    clearInterval(interval);
    intervalTime = intervalTime * speed;
    interval = setInterval(moveOutcome, intervalTime);
  }
}

The eatApple function is called from the moveSnake function every time the snake moves a step.

It receives two argument squares, .grid div and tail (basically the value that was popped up from the snake in moveOutcome). It then checks if the next position our snake moves to contains an apple.

If it does, it simply adds that tail we popped up back to the array. This is because every time our snake eats an apple we want to increase the length of the snake by one value – and what better way than to add the tail that was popped off when it moved?

Then we simply select a new position for our apple with randomApple (see below). After that we add a value of one to our score and display it to the user, clear the timeInterval (so that we can increase the speed of the snake, that is the time each movement happens) and then we simply set the interval back.

The randomApple function

function randomApple(squares) {
  do {
    appleIndex = Math.floor(Math.random() * squares.length);
  } while (squares[appleIndex].classList.contains("snake"));
  squares[appleIndex].classList.add("apple");
}

randomApple simply picks a spot to place our apple by using a do while loop. First it picks a random position with Math.random() in the do loop and checks if the spot it picked already contains a snake class.

This means that the condition in the do statement will keep on running until it finds a spot that does not contain a snake (keep doing this while this is true). Once it finds a spot it simply gives that spot a class of apple.

Set up controls

Now we need to set up our controls. We will start with keyboard users.

function control(e) {
  if (e.keycode === 39) {
    direction = 1; // right
  } else if (e.keycode === 38) {
    direction = -width; //if we press the up arrow, the snake will go ten divs up
  } else if (e.keycode === 37) {
    direction = -1; // left, the snake will go left one div
  } else if (e.keycode === 40) {
    direction = +width; // down the snake head will instantly appear 10 divs below from the current div
  }
}

Remember from above we set an eventListener for **keyup**. This function fires off immediately after your hand presses and. leaves a key on a keyboard.

Now each button on the keyboard has a value called keycode (numbers) which we have access to and let us know which number was clicked. Basically we will be watching for the arrow keys with their respective keycodes. With that we make changes to the direction, for example -1, 10 and so on.

Alright, I hope you understand how we are able to move the snake now.

Next, this set of buttons is for mobile devices and we are basically doing the same thing:

up.addEventListener("click", () => (direction = -width));
bottom.addEventListener("click", () => (direction = +width));
left.addEventListener("click", () => (direction = -1));
right.addEventListener("click", () => (direction = 1));

The final thing we need to do is create the replay div which will popup when the snake hits something. The button helps us reset the game.

The replay function

function replay() {
  grid.innerHTML = "";
  createBoard();
  startGame();
  popup.style.display = "none";
}

From above, we basically clear the grid (gameboard) and run the previous functions.

Congrats - you made it to the end! Here's the final result:

Final game

I hope you were able to code along and you enjoyed it.

In this tutorial, we learned how to create our own snake game with JavaScript. Some other important concepts we covered include push, pop, setInterval, clearInterval and eventListener.

You can check out the final game here: https://codepen.io/Fako29/pen/dyppXZG.

Thank you for reading. Follow me on Twitter here: https://twitter.com/fakoredeDami

Today we're lucky to have almost endless resources at our fingertips for learning web development. Among these resources are coding games.

I've created games like Flexbox Froggy and Grid Garden, along with others like CSS Diner and CodeCombat, that help package an educational experience into a fun, engaging format.

Yet, as with any learning resource, these questions frequently arise:

• Which coding games should I bother to invest my time in?
• How can I use coding games to learn most effectively?

In this article, I offer some tips to help you answer these questions based on my experiences as a game developer and educator.

Have a Gameplan

When you're starting out on a mission to learn web development, whether it involves games or not, you should start with a plan.

Though your plan doesn't need to be set in stone, having a strategy for what you want to accomplish and how you'll do it will already put you a few steps ahead.

When you're enrolled in a course or bootcamp, a lot of this planning is already done for you by experienced facilitators. freeCodeCamp offers a wonderfully organized curriculum as well.

But if you're self learning, all of the resources available on the web (which at once feels like a solitary void and a chaotic spectacle) can be overwhelming. So let's break it down.

When forming a plan, there are roughly three modes of learning you should target.

First is instruction. This is where you're introduced to a new concept or skill, whether in the form of videos, books, tutorials, or documentation. In the classroom, this could be a teacher on the whiteboard.

Second is practice, where you get to exercise your cognitive muscles and strengthen your grasp on those new concepts. This can take the form of practice problems, drills, or coding challenges.

Third is integration, where you incorporate your newly gained knowledge and skills into your existing practices. There's nothing better for this than project-based learning, where you apply what you've learned in a more authentic, well-rounded scenario.

An example of this is a web app you start as a weekend project. Even a relatively simple one will draw from all of the different facets of web development (and there are so many), helping you to contextualize what you've learned.

These three modes don't have rigid divisions, and many resources you come across will span more than one of them. Still, it's a useful way of thinking about and planning your learning.

Now when it comes to coding games, they too can fit in any of these modes. Many of the existing code games do have their greatest strength in the second mode — practice, with a small dose of instruction.

For example, in Flexbox Froggy, you're presented with a variety of challenges in how you position frogs using CSS flexbox, with each level ratcheting up the difficulty.

By the end, you'll have applied the Flexbox properties many times, in many combinations, to the point that they start becoming second nature.

Move the frogs to their lily pads using CSS flexbox.

Through this lens, you can see that coding games best serve as a complement to other resources you may use, including freeCodeCamp's lessons.

Be a Critic

The next question you might have is which coding games you should play. Rather than provide you a static list, I encourage you to evaluate them yourself the same as you would any reference you come across.

First, consider the game from an entertainment angle. It is a game after all, and should be fun for you. Next, consider the pedagogical angle. That is, what am I learning from the game, and am I learning it effectively?

Educational game designers have to walk a tightrope in balancing fun with learning. For something that leans more on the learning, there are many resources inside and outside of gaming.

But beware the other direction, a game with merely a facade of educational substance. A coding game can fail when the educational content is too shallow or there are too many other game mechanics that distract you from engaging with what you need to learn.

Evaluating a learning resource on your own can be difficult, especially as a beginner. So your evaluation should also weigh the perspectives of others.

Consult with a trusted mentor or blogger. Or look for resources that have positive recommendations in your community: in the freeCodeCamp forums, web dev subreddits, or your favorite Discord or Slack group.

Press Start Now

Even if you ask yourself the same questions as everyone else about how to best fit coding games into your learning plan, everyone will have a different answer. There is no one-size-fits-all solution.

Your learning style and what sparks your passion will depend on your experiences, preferences, and goals. So what I encourage you to do is start today, have fun with it, and discover what works for you.

Though the idea of coding games that help you learn web dev has been around for years, the genre is still in its infancy. There is so much untapped potential to the idea that you can learn in a fun, interactive, immersive environment, and games are a great vehicle for that.

Fortunately for us, more coding games are becoming available all the time. I welcome you to stop by Codepip and play a coding game for yourself today.

Technological breakthroughs, patience, and refined skills will get us there, but the first step is to understand procedural content generation.

Though many out-of-the-box solutions for map generation exist, this tutorial will teach you to make your own two-dimensional dungeon map generator from scratch using JavaScript.

There are many two-dimensional map types, and all have the following characteristics:

1. Accessible and inaccessible areas (tunnels and walls).

2. A connected route the player can navigate.

The algorithm in this tutorial comes from the Random Walk Algorithm, one of the simplest solutions for map generation.

After making a grid-like map of walls, this algorithm starts from a random place on the map. It keeps making tunnels and taking random turns to complete its desired number of tunnels.

To see a demo, open the CodePen project below, click on the map to create a new map, and change the following values:

1. Dimensions: the width and height of the map.
2. MaxTunnels: the greatest number of turns the algorithm can take while making the map.
3. MaxLength: the greatest length of each tunnel the algorithm will choose before making a horizontal or vertical turn.

Note: the larger the maxTurn is compared to the dimensions, the denser the map will be. The larger the maxLength is compared to the dimensions, the more “tunnel-y” it will look.

Next, let’s go through the map generation algorithm to see how it:

1. Makes a two dimensional map of walls
2. Chooses a random starting point on the map
3. While the number of tunnels is not zero
4. Chooses a random length from maximum allowed length
5. Chooses a random direction to turn to (right, left, up, down)
6. Draws a tunnel in that direction while avoiding the edges of the map
7. Decrements the number of tunnels and repeats the while loop
8. Returns the map with the changes

This loop continues until the number of tunnels is zero.

The Algorithm in Code

Since the map consists of tunnel and wall cells, we could describe it as zeros and ones in a two-dimensional array like the following:

map = [[1,1,1,1,0],
       [1,0,0,0,0],
       [1,0,1,1,1],       
       [1,0,0,0,1],       
       [1,1,1,0,1]]

Since every cell is in a two-dimensional array, we can access its value by knowing its row and column such as map [row][column].

Before writing the algorithm, you need a helper function that takes a character and dimension as arguments and returns a two-dimensional array.

createArray(num, dimensions) {
    var array = [];    
    for (var i = 0; i < dimensions; i++) { 
      array.push([]);      
      for (var j = 0; j < dimensions; j++) {  
         array[i].push(num);      
      }    
    }    
    return array;  
}

To implement the Random Walk Algorithm, set the dimensions of the map (width and height), themaxTunnels variable, and themaxLength variable.

createMap(){
 let dimensions = 5,     
 maxTunnels = 3, 
 maxLength = 3;

Next, make a two-dimensional array using the predefined helper function (two dimensional array of ones).

let map = createArray(1, dimensions);

Set up a random column and random row to create a random starting point for the first tunnel.

let currentRow = Math.floor(Math.random() * dimensions),       
    currentColumn = Math.floor(Math.random() * dimensions);

To avoid the complexity of diagonal turns, the algorithm needs to specify the horizontal and vertical directions. Every cell sits in a two-dimensional array and could be identified with its row and column. Because of this, the directions could be defined as subtractions from and/or additions to the column and row numbers.

For example, to go to a cell around the cell [2][2], you could perform the following operations:

• to go up, subtract 1 from its row [1][2]
• to go down, add 1 to its row [3][2]
• to go right, add 1 to its column [2][3]
• to go left, subtract 1 from its column [2][1]

The following map illustrates these operations:

Operational options grid

Now, set the directions variable to the following values that the algorithm will choose from before creating each tunnel:

let directions = [[-1, 0], [1, 0], [0, -1], [0, 1]];

Finally, initiate randomDirection variable to hold a random value from the directions array, and set the lastDirection variable to an empty array which will hold the older randomDirection value.

Note: the lastDirection array is empty on the first loop because there is no older randomDirection value.

let lastDirection = [], 
    randomDirection;

Next, make sure maxTunnel is not zero and the dimensions and maxLengthvalues have been received. Continue finding random directions until you find one that isn’t reverse or identical to lastDirection. This do while loop helps to prevent overwriting the recently-drawn tunnel or drawing two tunnels back-to-back.

For example, if your lastTurn is [0, 1], the do while loop prevents the function from moving forward until randomDirection is set to a value that is not [0, 1] or the opposite [0, -1].

do {         
randomDirection = directions[Math.floor(Math.random() * directions.length)];      
} while ((randomDirection[0] === -lastDirection[0] &&    
          randomDirection[1] === -lastDirection[1]) || 
         (randomDirection[0] === lastDirection[0] &&  
          randomDirection[1] === lastDirection[1]));

In the do while loop, there are two main conditions that are divided by an || (OR) sign. The first part of the condition also consists of two conditions. The first one checks if the randomDirection’s first item is the reverse of the lastDirection’s first item. The second one checks if the randomDirection’s second item is the reverse of the lastTurn’s second item.

To illustrate, if the lastDirection is [0,1] and randomDirection is [0,-1], the first part of the condition checks if randomDirection[0] === — lastDirection[0]), which equates to 0 === — 0, and is true.

Then, it checks if (randomDirection[1] === — lastDirection[1]) which equates to (-1 === -1) and is also true. Since both conditions are true, the algorithm goes back to find another randomDirection.

The second part of the condition checks if the first and second values of both arrays are the same.

After choosing a randomDirection that satisfies the conditions, set a variable to randomly choose a length from maxLength. Set tunnelLength variable to zero to server as an iterator.

let randomLength = Math.ceil(Math.random() * maxLength),       
    tunnelLength = 0;

Make a tunnel by turning the value of cells from one to zero while the tunnelLength is smaller than randomLength. If within the loop the tunnel hits the edges of the map, the loop should break.

while (tunnelLength < randomLength) { 
 if(((currentRow === 0) && (randomDirection[0] === -1))||  
    ((currentColumn === 0) && (randomDirection[1] === -1))|| 
    ((currentRow === dimensions — 1) && (randomDirection[0] ===1))||
 ((currentColumn === dimensions — 1) && (randomDirection[1] === 1)))   
 { break; }

Else set the current cell of the map to zero using currentRow and currentColumn. Add the values in the randomDirection array by setting currentRow and currentColumn where they need to be in the upcoming iteration of the loop. Now, increment the tunnelLength iterator.

else{ 
  map[currentRow][currentColumn] = 0; 
  currentRow += randomDirection[0];
  currentColumn += randomDirection[1]; 
  tunnelLength++; 
 } 
}

After the loop makes a tunnel or breaks by hitting an edge of the map, check if the tunnel is at least one block long. If so, set the lastDirection to the randomDirection and decrement maxTunnels and go back to make another tunnel with another randomDirection.

if (tunnelLength) { 
 lastDirection = randomDirection; 
 maxTunnels--; 
}

This IF statement prevents the for loop that hit the edge of the map and did not make a tunnel of at least one cell to decrement the maxTunnel and change the lastDirection. When that happens, the algorithm goes to find another randomDirection to continue.

When it finishes drawing tunnels and maxTunnels is zero, return the resulting map with all its turns and tunnels.

}
 return map;
};

You can see the complete algorithm in the following snippet:

Congratulations for reading through this tutorial. You are now well-equipped to make your own map generator or improve upon this version. Check out the project on CodePen and on GitHub as a react application.

Thanks for reading! If you liked this story, don't forget to share it on social media.

Special thanks to Tom for co-writing this article.

Dino says no internet today

Many people probably just thought the dinosaur was a cute little icon to keep them company while their connection was down. But then someone pressed the space bar. And the dino started running.

This little Easter egg has become a beloved game. But what if you just want to play it (careful, it's addictive) when you're online and need a break? In this article, you'll learn how to play the game when you're both off and online.

How to play the Chrome dino or Trex game offline

If your internet is down, just open Chrome. Or if you're already in Chrome, try to visit any web page. You'll see that little dinosaur next to its error message.

Simply press the space bar (or up arrow) and the dino will start running. Press the up arrow to jump over the obstacles (like cacti) in your path. The longer you hold the up arrow, the higher dino will jump.

If you need to duck under something, press the down arrow.

The longer you play, the faster dino runs/the ground moves. Once you crash into something, the game is over and you have to restart (your score resets, too). You can play again by hitting the space bar.

How to play the Chrome dino or Trex game online

Great, you have some entertainment while waiting for your internet to come back up. But what if you want to play it while online? There are a few ways to do so.

Visit the dino URL

The simplest way to play the game online is by visiting this URL: chrome://dino/. Just access that link and voilà, there's your little dino and "no internet" message.

Once you see that message, just hit the spacebar and start jumping over cacti.

There is also an unofficial Chrome Dino website where you can play a replica of the game with different sound and graphics themes, such as this Super Mario Bros. theme:

Or this Batman theme with 1960s Batman sound effects:

Bonus: Another way to find the game

Maybe you didn't get the dino error message when your internet was down. Or maybe you don't want to purposely turn off your wifi to play the game.

So, if you have internet but want to disable your connection in Chrome dev tools, hit F12 to open up dev tools.

Click the "Network" tab at the top towards the right, and then look for the Online/Offline tab, second row down:

Look for the little dropdown arrow next to where it says "online".

Look for the little dropdown arrow, click it, and select "Offline" (instead of "Online", where it should be set if you currently have a connection).

Toggle to "Offline"

Once you've done that, if you try to visit a web page, you'll get the dinosaur! You can exit dev tools and hit the space bar, as usual, to get dino running.

Play away!

Now you know how to find the dino/Trex game without AND with internet connectivity. Have fun!

If you are learning Web development or are already a professional Web developer, there is a very high chance you have written CSS at least once in your life. It is a very basic building block of any webpage. Amidst all the discussions and love and hate for CSS, we present to you all — CSSBattle ?⚔️

CSSBattle is the first ever code-golfing platform for CSS lovers that I and my friend, Kushagra Agarwal, have created. The aim of this game is simple — you have an image target which you need to replicate with the smallest possible CSS (and slight HTML if you please) code. More visual match and fewer bytes get you a higher score. And that is how you climb the leaderboards in CSSBattle. Here is an example target screen:

Target #9 play screen

Some fun stats

At the time of writing this post, it has been 10 days since we launched. And here are some fun stats we have gathered:

• 13000+ players worldwide
• Over 100K code submissions
• Minimum bytes used on a target: just 54 bytes! ?
• A lovely community forum of 140+ players and 40+ conversations

Product development

We decided to build and launch CSSBattle in one month, to prevent ourselves from getting into an infinite loop of adding and polishing features. We made a list of the absolutely necessary items for launch and focused on it.

During the development, we came up with tons of new ideas to implement in the website, which we kept noting down. I am proud we could resist the urge to work on those exciting ideas and finally launch in one month!

Tech Stack

Our tech stack is pretty standard for today’s product. We have React (using create-react-app as a starter) on the frontend which is deployed on Zeit Now. For the backend, we use Firebase. Since we both primarily have frontend/design experience, Firebase turned out to be an amazing option to easily implement everything we had on our mind while getting best in class scalability and security without managing any server!

The scoring algorithm

One of the most interesting things about developing CSSBattle was designing the scoring algorithm. We sat literally for days discussing and trying out various formulas. We wanted that a amore visual match should always result in a higher score. And of course, for the same match percentage, the score should increase with decreasing code bytes. Also, we wanted a faster score progression towards lower bytes once you are at 100% match, to make it more rewarding for the players who sweat it out with each removed byte.

In the end, we are happy with what we came up with. Maybe we’ll write a separate post about just the scoring algorithm :)

The Launch

We originally planned the launch for the 5th of April, but we had to launch it a day before. We had invited many eminent CSS developers to try out CSSBattle before going public. And “fortunately” Jonathan Snook tweeted about us a day before we planned to launch, sending in a huge stream of developers to the game! And so we decide to prepone our launch :)

We started with the announcement on ProductHunt where CSSBattle was the #1 product of the day. Immediately following it was a Reddit rush. And then, the massive and really encouraging tweet by Lea Verou:

Since then, it has been a crazy ride for us both seeing the community grow, play, learn and compete! Each day we see players breaking the limits of creativity and imagination with CSS!

Come join us

We have a very lovely community of superbly creative and humble developers on Spectrum where you can hang out and learn some CSS Trickery.

So, what are you waiting for? If you have ever written CSS, play now — https://cssbattle.dev
(We have also seen people wanting to learn CSS just to play this game!)

⚠️ Fair warning

CSSBattle is highly fun and addictive. We have seen people losing their sleep, having weird dreams, being late to meet friends, cursing, skipping project deadlines and what not. Please enter at your own risk! ?

Also, we feel it’s our responsibility to highlight that apart from creative approaches, CSSBattle requires you to exploit how CSS (and HTML) is parsed by browsers. It’s important to understand that the CSS you write here is not the way you would write in a real project. The tips and tricks you learn while playing here would certainly make you better understand CSS, but always be alert and curious about what’s a hack and what is not.

Have fun CSS-ing!

Have you ever wanted to learn some advanced React patterns? Or build your own game engine? If at least one answer is yes, then this article is for you.

In this tutorial, you’ll learn how to build basic sprite animation using React, styles-components, and requestAnimationFrame. At the end you’ll be able to create characters like this:

You may ask me why can’t I learn it another way? Well… There’re three reasons for that:

So, let’s do it! ?

Let’s start with a bit of a theory

What is a sprite animation? Wikipedia says that

In computer graphics, a sprite is a two-dimensional bitmap that is integrated into a larger scene.

So basically sprite animation is a repeatedly changing two-dimensional bitmap.

Sprite is usually represented like a png image with different states of the animation:

Bitmap image

We’ll start by creating a tile component that will show us one frame at a time and allow us to change frames with state property:

Basically, we’ll need to show one part of the image at a time and hide the rest. Pretty straightforward.

Tile

First of all, we’ll create a container component to create the shape of our frame:

width and height represent the size of the tale, and scale increases the size of the image. overflow: hidden will hide the unused part of the image and transform-origin will make a container to keep its top and left the same when we scale it.

Now we need to adjust the position of the inner image. We’ll use the transform: translate CSS property for that:

Now let’s combine everything together in the tile component:

• src property contains a link to the image
• tile is the object with width and height fields, represents the size of the tile
• state frame index
• scale property to increase the size of the image (For example, scale = 2 is 2x image)

In the next step, we’ll add some movement to our image.

Sprite

We’ll use requestAnimationFrame for that. You may ask why we don’t use setTimeout or setInterval. The problem with timeouts is that the callback will fire somewhere in between frames, that may result in clunky animation.

requestAnimationFrame vs setInterval

Also, requestAnimationFrame allows us to synchronize animations of different objects on the screen. In the game you’ll have lots of them!

Let’s put together a Sprite component:

In the animate function, we should change the state of the frame and request a new animation frame:

We use the eframesPerStep property to control the number of states per frame, so our animation won’t be too fast.

What about a gun? ?

Now the only thing we need to do is combine our sprite with the gun image:

And you should get the following result:

The best way to learn something it to build it by yourself. So I encourage you to use this codesandbox:

The TypeScript version is available here as well.

As a bonus, you can implement different animations using files from the assets folder.

You can find the source code here. I used game assets made by finalbossblues.

Hope you enjoyed the article! ?

Follow me on Medium and Twitter to get more updates on new articles. Also, share this article to help others know about it. Sharing is caring ?

Destroy this clap button if you want more.

You can clap up to 50 times! ?

Some more resources about the topic:

Understanding JavaScript's requestAnimationFrame() method for smooth animations
_requestAnimationFrame() is a JavaScript method for creating smoother, less resource intensive JavaScript animations…_www.javascriptkit.com

Originally published at react.camp.

Hello there ?

Welcome on board. Today we will embark on an exciting adventure, where we will be making our very own snake game ?. You’ll learn how to work through a problem by breaking it down into smaller simpler steps. By the end of this journey, you will have learned some new things, and you’ll feel confident to explore more on your own.

If you are new to programming, I recommend checking out freeCodeCamp. It’s a great place to learn for…you guessed it…free. That’s how I got started ?

Okay, okay enough messin’ around — are you ready to start?

You can find the final code here and a live demo here.

Getting Started

Let’s begin by creating a file “snake.html” that will contain all our code.

Since this is an HTML file, the first thing we need is the [<!DOCTY](https://www.w3schools.com/tags/tag_doctype.asp)PE> declaration . In snake.html type the following:

Great, now go ahead and open snake.html in your preferred browser. You should be able to see Welcome to Snake!

snake.html opened in chrome

We are off to a good start ?

Creating the Canvas

To be able to create our game, we have to make use of HTML [<canv](https://www.w3schools.com/html/html5_canvas.asp)as> . This is what is used to draw graphics using JavaScript.

Replace the welcome message in snake.html with the following:

<canvas id="gameCanvas" width="300" height="300">&lt;canvas>

The id is what identifies the canvas and should always be specified. We will use it to access the canvas later. The width and height are the dimensions of the canvas, and should also be specified. In this case, 300 x 300 pixels.

Your snake.html file should now look like this.

If you refresh your browser page where you previously opened snake.html you will now see a blank page. This is because, by default, the canvas is empty and has no background. Lets fix that. ?

Give the canvas a background colour and a border

To make our canvas visible, we can give it a border by writing some JavaScript code. To do that, we need to insert <script><;/script> tags after the , where all our JavaScript code will go.

If you put the _<scri_pt> tag befor_e the &l_t;canvas> your code won’t work, as the HTML will not be loaded.

We can now write some JavaScript code, between the enclosing<script><;/script> tags. Update your code as below.

First we get the canvas element using the id (gameCanvas) we specified earlier. We then get the canvas “2d” context, which means we will be drawing into 2D space.

Finally we draw a 300 x 300 white rectangle with a black border. This covers the entire canvas, starting from the top left corner (0, 0).

If you reload snake.html in your browser, you should see a white box with a black border! Good job, we have a canvas that we can use to create our snake game! ? On to the next challenge!

Representing our snake

For our snake game to work, we need to know the location of the snake on the canvas. To do that, we can represent the snake as an array of coordinates. Thus, to create a horizontal snake in the middle of the canvas (150, 150) we can write the following:

let snake = [  {x: 150, y: 150},  {x: 140, y: 150},  {x: 130, y: 150},  {x: 120, y: 150},  {x: 110, y: 150},];

Notice that the y coordinate for all parts is always 150. The x coordinate of each part is -10px (to the left) of the previous part. The first pair of coordinates in the array {x: 150, y: 150} represents the head at the very right of the snake.

This will become clearer when we draw the snake in the next section.

Creating and drawing our snake

To display the snake on the canvas, we can write a function to draw a rectangle for each pair of coordinates.

function drawSnakePart(snakePart) {  ctx.fillStyle = 'lightgreen';  ctx.strokestyle = 'darkgreen';

  ctx.fillRect(snakePart.x, snakePart.y, 10, 10);  ctx.strokeRect(snakePart.x, snakePart.y, 10, 10);}

Next we can create another function that prints the parts on the canvas.

function drawSnake() {  snake.forEach(drawSnakePart);}

Our snake.html file should now look like this:

If you refresh your browser page now you will see a green snake in the middle of the canvas. Awesome! ?

Enabling the snake to move horizontally

Next we want to give the snake the ability to move. But how do we do that? ?

Well, to make the snake move one step (10px) to the right, we can increase the x-coordinate of every part of the snake by 10px (dx = +10px). To make the snake move to the left, we can decrease the x-coordinate of every part of the snake by 10px (dx = -10).

dx is the horizontal velocity of the snake.

Creating a snake that has moved 10px to the right should then look like this

Create a function called advanceSnake that we will use to update the snake.

function advanceSnake() {  const head = {x: snake[0].x + dx, y: snake[0].y};

  snake.unshift(head);

  snake.pop();}

First we create a new head for the snake. We then add the new head to the beginning of snake using unshift and remove the last element of snake using pop. This way all the other snake parts shift into place as shown above.

Boom ?, you are getting the hang of this.

Enabling the snake to move vertically

To move our snake up and down, we can’t alter all y-coordinates by 10px. That would shift the whole snake up and down.

Instead we can alter the y-coordinate of the head. Decreasing it by 10px to move the snake down, and increasing it by 10px to move the snake up. This will make the snake move correctly.

Luckily, because of the way we wrote the advanceSnake function, this is very easy to do. Inside advanceSnake, update the head to also increase the y-coordinate of the head by dy.

const head = {x: snake[0].x + dx, y: snake[0].y + dy};

To test how our advanceSnake function works, we can temporarily call it before the drawSnake function.

// Move on step to the rightadvanceSnake()

// Change vertical velocity to 0dx = 0;// Change horizontal velocity to 10dy = -10;

// Move one step upadvanceSnake();

// Draw snake on the canvasdrawSnake();

This is how our snake.html file looks so far.

Refreshing the browser, we can see that our snake has moved. Success!

Refactoring our code

Before we move on, let’s do some refactoring and move the code that draws the canvas inside a function. This will help us in the next section.

“Code refactoring is the process of restructuring existing computer code, without changing its external behaviour.” -wikipedia

function clearCanvas() {  ctx.fillStyle = "white";  ctx.strokeStyle = "black";

  ctx.fillRect(0, 0, gameCanvas.width, gameCanvas.height);  ctx.strokeRect(0, 0, gameCanvas.width, gameCanvas.height);}

We are making great strides! ?

Making our snake move automatically

Okay, now that we have successfully refactored our code, we can make our snake move automatically.

Earlier, to test that our advanceSnake function worked, we called it twice. Once to make the snake move to the right, and once to make the snake move up.

Thus if we wanted to make the snake move five steps to the right we would call advanceSnake() five times in a row.

clearCanvas();advanceSnake();advanceSnake();advanceSnake();advanceSnake();advanceSnake();drawSnake();

But, calling it five times in a row as shown above, will make the snake jump 50px forward.

Instead we want to make the snake appear to be moving forward step by step.

To do that, we can add a slight delay between each call, using setTimeout. We also need to make sure to call drawSnake every time we call advanceSnake. If we don’t, we won’t be able to see the intermediate steps that show the snake moving.

setTimeout(function onTick() {  clearCanvas();  advanceSnake();  drawSnake();}, 100);

setTimeout(function onTick() {  clearCanvas();  advanceSnake();  drawSnake();}, 100);

...

drawSnake();

Notice how we also call _clearCanvas()_ inside each _setTimeout_. This is to remove all the previous positions of the snake that would leave a trail behind.

Although, there is a problem with the above code. There is nothing here to tell the program that it has to wait for setTimeout before it moves to the next setTimeout. This means that the snake will still jump 50px forward but after a slight delay.

To fix that, we have to wrap our code inside functions, calling one function at a time.

stepOne();    function stepOne() {  setTimeout(function onTick() {    clearCanvas();    advanceSnake();    drawSnake();   // Call the second function   stepTwo();  }, 100)}

function stepTwo() {  setTimeout(function onTick() {    clearCanvas();    advanceSnake();    drawSnake();    // Call the third function    stepThree();  }, 100)}

...

How do we make our snake keep moving? Instead of creating an infinite number of functions that call each other, we can instead create one function main and call it over and over again.

function main() {  setTimeout(function onTick() {    clearCanvas();    advanceSnake();    drawSnake();

    // Call main again    main();  }, 100)}

Voilà! We now have a snake that will keep moving to the right. Although, once it reaches the end of the canvas, it continues its infinite journey into the unknown ?. We will fix that in due time, patience young padawan. ?.

Changing the snake’s direction

Our next task is to change the snake’s direction when one of the arrow keys is pressed. Add the following code after the drawSnakePart function.

function changeDirection(event) {  const LEFT_KEY = 37;  const RIGHT_KEY = 39;  const UP_KEY = 38;  const DOWN_KEY = 40;

  const keyPressed = event.keyCode;  const goingUp = dy === -10;  const goingDown = dy === 10;  const goingRight = dx === 10;  const goingLeft = dx === -10;

  if (keyPressed === LEFT_KEY && !goingRight) {    dx = -10;    dy = 0;  }

  if (keyPressed === UP_KEY && !goingDown) {    dx = 0;    dy = -10;  }

  if (keyPressed === RIGHT_KEY && !goingLeft) {    dx = 10;    dy = 0;  }

  if (keyPressed === DOWN_KEY && !goingDown) {    dx = 0;    dy = 10;  }}

There is nothing tricky going on here. We check if the key pressed matches one of the arrow keys. If it does, we change the vertical and horizontal velocity as described earlier.

Notice that we also check if the snake is moving in the opposite direction of the new intended direction. This is to prevent our snake from reversing, for example when you press the right arrow key when the snake is moving to the left.

Snake reversing

To connect changeDirection to our game, we can use addEventListener on the document to ‘listen’ for when a key is pressed. Then we can call changeDirection with the keydown event. Add the following code after the main function.

document.addEventListener("keydown", changeDirection)

You should now be able to change the snake’s direction using the four arrow keys. Great work, you are on fire?!

Next lets see how we can generate food and grow our snake.

Generating food for the snake

For our snake food, we have to generate a random set of coordinates. We can use a helper function randomTen to produce two numbers. One for the x-coordinate and one for the y-coordinate.

We also have to make sure that the food is not located where the snake currently is. If it is, we have to generate a new food location.

function randomTen(min, max) {  return Math.round((Math.random() * (max-min) + min) / 10) * 10;}

function createFood() {  foodX = randomTen(0, gameCanvas.width - 10);  foodY = randomTen(0, gameCanvas.height - 10);

  snake.forEach(function isFoodOnSnake(part) {    const foodIsOnSnake = part.x == foodX && part.y == foodY    if (foodIsOnSnake)      createFood();  });}

We then have to create a function to draw the food on the canvas.

function drawFood() { ctx.fillStyle = 'red'; ctx.strokestyle = 'darkred'; ctx.fillRect(foodX, foodY, 10, 10); ctx.strokeRect(foodX, foodY, 10, 10);}

Finally we can call createFood before calling main. Don’t forget to also update main to use the drawFood function.

function main() {  setTimeout(function onTick() {    clearCanvas();    drawFood()    advanceSnake();    drawSnake();

    main();  }, 100)}

Growing the snake

Growing our snake is simple. We can update our advanceSnake function to check if the head of the snake is touching the food. If it is we can skip removing the last part of the snake and create a new food location.

function advanceSnake() {  const head = {x: snake[0].x + dx, y: snake[0].y};

  snake.unshift(head);

  const didEatFood = snake[0].x === foodX && snake[0].y === foodY;  if (didEatFood) {    createFood();  } else {    snake.pop();  }}

Keeping track of the score

To make the game more enjoyable for the player, we can also add a score that increases when the snake eats food.

Create a new variable score and set it to 0 after the snake declaration.

let score = 0;

Next add a new div with an id “score” before the canvas. We can use this to display the score.

<div id="score">0</div><canvas id="gameCanvas" width="300" height="300"></canvas>

Finally update advanceSnake to increase and display the score when the snake eats the food.

function advanceSnake() {  ...

  if (didEatFood) {    score += 10;    document.getElementById('score').innerHTML = score;

    createFood();  } else {    ...  }}

Pheew, that was quite a lot, but we have come a long way ?

End the game

There is one final piece left, and that is to end the game ?. To do that we can create a function didGameEnd that returns true when the game has ended or false otherwise.

function didGameEnd() {  for (let i = 4; i < snake.length; i++) {    const didCollide = snake[i].x === snake[0].x &&      snake[i].y === snake[0].y

    if (didCollide) return true  }

  const hitLeftWall = snake[0].x < 0;  const hitRightWall = snake[0].x > gameCanvas.width - 10;  const hitToptWall = snake[0].y &lt; 0;  const hitBottomWall = snake[0].y > gameCanvas.height - 10;

  return hitLeftWall ||          hitRightWall ||          hitToptWall ||         hitBottomWall}

First we check if the snake’s head touches another part of the snake and return true if it does.

Notice that we start our loop from index 4. There are two reasons for that. The first is that didCollide would immediately evaluate to true if the index was 0, so the game would end. The second is that, it is impossible for the first three parts to touch each other.

Next we check if the snake hit any of the canvas walls and return true if it did, otherwise we return false.

Now we can return early in our main function if didEndGame returns true, thus ending the game.

function main() {  if (didGameEnd()) return;

  ...}

Our snake.html should now look like this:

You now have a functioning snake game that you can play and share with your friends. But before celebrating lets look at one final problem. This will be the last one, I promise.

Sneaky bugs ?

If you play the game enough times, you might notice that sometimes the game ends unexpectedly. This is a very good example on how bugs can sneak into our programs and cause trouble ?.

When a bug occurs, the best way to solve it is to first have a reliable way of reproducing it. That is, come up with the precise steps that lead to the unexpected behaviour. Then you need to understand why they cause the unexpected behaviour and then come up with a solution.

Reproducing the bug

In our case, the steps taken to reproduce the bug are as follows:

• The snake is moving to the left
• The player presses the down arrow key
• The player immediately presses the right arrow key (before 100ms have lapsed)
• The game ends

Making sense of the bug

Let’s break down what happens step by step.

Snake is moving to the left

• Horizontal velocity, dx is equal to -10
• main function is called
• advanceSnake is called which advances the snake -10px to the left.

The player presses the down arrow key

• changeDirection is called
• keyPressed === DOWN_KEY && dy !goingUp evaluates to true
• dx changes to 0
• dy changes to +10

Player immediately presses the right arrow (before 100ms have lapsed)

• changeDirection is called
• keyPressed === RIGHT_KEY && !goingLeft evaluates to true
• dx changes to +10
• dy changes to 0

The game ends

• main function is called after 100ms have lapsed.
• advanceSnake is called which advances the snake 10px to the right.
• const didCollide = snake[i].x === snake[0].x && snake[i].y === snake[0].y evaluates to true
• didGameEnd returns true
• main function returns early
• The game ends

Fixing the bug

After studying what happened, we learn that the game ended because the snake reversed.

That is because when the player pressed the down arrow, dx was set to 0. Thus keyPressed === RIGHT_KEY && !goingLeft evaluated to true, and dx changed to 10.

It is important to note that the change in direction occurred before 100ms had lapsed. If 100ms lapsed, then the snake would have first taken a step down and would not have reversed.

To fix our bug, we have to make sure that we can only change direction after main and advanceSnake have been called. We can create a variable changingDirection. This will be set to true when changeDirection is called, and to false when advanceSnake is called.

Inside our changeDirection function, we can return early if changingDirection is true.

function changeDirection(event) {  const LEFT_KEY = 37;  const RIGHT_KEY = 39;  const UP_KEY = 38;  const DOWN_KEY = 40;

  if (changingDirection) return;

  changingDirection = true;

  ...}

function main() {  setTimeout(function onTick() {    changingDirection = false;        ...

  }, 100)}

Here is our final version of snake.html

Notice I also added some styles ? between the &_lt;style><_;/style> tags. That is to make the canvas and score appear in the middle of the screen.

Conclusion

Congratulations!! ??

We have reached the end of our journey. I hope you enjoyed learning with me and now feel confident to continue on to your next adventure.

But it doesn’t have to end here. My next article will focus on helping you get started with the very exciting world of open source.

Open source is a great way to learn a lot of new things and get to know amazing people . It is very rewarding but can can be scary at first ?.

To get a notification when my next article is out, you can follow me! ?

It was a pleasure to be on this journey with you.

Till next time. ✨

What is the DOM ?

DOM stands for Document Object Model. It’s nothing more than the block level diagram of all the HTML elements loaded on the page when a browser loads a web page. It is presented as a tree of objects which are HTML elements. Look at the image below and you may get a better idea.

DOM representation of a simple .html file

A nice clean block diagram of your ugly .html file — isn’t that great! But now you are thinking, how does this help me? What’s the use case? Why do I need to know this?

To put it simply, the DOM enables you to bring dynamics to your static website. With the use of the DOM, you can do a bunch of useful things on the webpage like:

• adding and deleting HTML elements and attributes
• adding and deleting CSS rules on a user fired event
• creating new events for synthetic user events

And this is exactly what you will learn throughout the course of this article.

To give you an idea of what we will achieve by the end of this article, check out this link.

Getting started

We will build a simple color guessing game. Every time the game is started, a random RGB color code will be selected. Depending on the mode of the game, we will have three (easy) or six (hard) options or color blocks on the screen to choose from. Every time an incorrect color block is selected, the block will disappear until the user selects the correct color (or its the last option left).

Here’s a rough diagram of what we would be building:

This is something I learnt while I was taking a course from Colt Steele, phenomenal trainer when it comes to teaching basic concepts. You all should check out his videos on Udemy’s YouTube channel.

Mockup diagram

Part 1

We’ll start by creating a simple web boiler plate, which will be compromised of index.html, app.css, and app.js files. Let’s see how these files look when we’re starting out.

But first, please note: just to keep it simple for anyone who is reading this without any prior development experience, I will keep showing the source code whenever we change something major.

• index.html

<!DOCTYPE html><html>

<head><title>Color Game</title><link rel="stylesheet" type="text/css" href="app.css"></head>

<body>

<h1>The Great<br><span id="colorDisplay">RGB</span><br>Color Game</h1>

<div id="stripe">

<button id="reset">New Colors</button><span id="message"></span><button class="mode">Easy</button><button class="mode selected">Hard</button>

</div>

<div id="container">

<div class="square"></div><div class="square"></div><div class="square"></div><div class="square"></div><div class="square"></div><div class="square"></div>

</div>

<script type="text/javascript" src="app.js"></script></body></html>

This is as simple as it gets. We can simply segregate the entire webpage in three primary blocks.

First we have the header section, which has the text and may contain some other information if you want to add it in there.

Next is the control panel, which has buttons to reset the game and to switch between the game modes.

Third — and the most interesting part — is the main game area, which has six divs. These divs serve as the options for every random RGB color code which can be selected by some fancy logic (which we will see in a while).

• app.css

body {

background-color: #232323;margin: 0;font-family: "Montserrat", "Avenir";}

h1 {

text-align: center;line-height: 1.1;font-weight: normal;color: white;background: steelblue;margin: 0;text-transform: uppercase;padding: 20px 0;}

#container {

margin: 20px auto;max-width: 600px;}

.square {

width: 30%;background: purple;padding-bottom: 30%;float: left;margin: 1.66%;border-radius: 15%;transition: background 0.6s;-webkit-transition: background 0.6s;-moz-transition: background 0.6s;}

Some basic styles have been added for the body, text, and squares that serve as the game options.

• app.js

var numSquares = 6;var colors = [];var pickedColor;var squares = document.querySelectorAll(".square");var resetButton = document.querySelector("#reset");var modeButtons = document.querySelectorAll(".mode");

We have stored all the HTML elements in the form of variables. This will help us perform some actions by adding events to each of these variables, and by calling them inside various logic functions we will create during this article.

In fact, let’s break each of these variables down and see what their significance is:

• The numSquares variable stores the number of squares that will be available in the game as per the mode. For simplicity’s sake, I have hard coded the value to be six always — we can come back to this and add some logic to keep it changing.
• colors is an empty array which contains the random six or three RGB color code generated every time the game is reset or the mode is changed.
• pickedColor is the color/option block selected by the user upon every click.
• squares is an array of all the squares on the page that are available as options. This array may have three or six elements depending on the mode of the game.
• The reset variable is the “new game” button in the control panel.
• modeButtons is again an array which has easy and hard mode buttons in it.

If you have followed up to this point, here you should have a pretty basic version of this game. You may open the index.html file in any browser and check it out. All right, so now that we have the ground set, let’s get to the serious stuff.

Part 2

In this section, we will mostly be working with the JavaScript file and a few times with the CSS file.

Generating random colours

Our first goal will generating random colors every time the game is started or restarted or the mode is changed. Let’s see how can do that.

To understand the underlying principle of generating anything randomly, we should start with a hard coded array of six RGB color codes. Let’s try to set those colors as the background colors of the six squares/options available on the webpage.

var colors = [

    "rgb(255, 0, 0)",    "rgb(255, 0, 255)",    "rgb(255, 225, 0)",    "rgb(255, 0, 255)",    "rgb(0, 255, 255)",    "rgb(0, 255, 0)"

];

var squares = document.querySelectorAll(.squares);

for (i=0; i<squares.length; i++) {squares.style.backgroundColor = colors[i]}

• I added six static RGB color codes to the color array
• I used the already created squares array to run a loop across all the squares present in the array.
• I matched the background color of each square to its corresponding index in the colors array.

If you add this to the app.js file and you refresh the browser, you will see that each square is now a unique color.

*screenshot form the browser

You might notice that the buttons are not yet styled, but leave that for now. We will come to that part later on.

Enable Click Functionality

So all we need is event listeners enabled on each option/color block listening for click events. The easiest way to do that is — again you guessed it right — by looping through the array of squares. This loop would look similar to that which was used to style the background of the color blocks. Let’s take a look at the code:

for(i=0; i<= squares.length; i++) {  squares[i].addeventListeners('click', function() {    alert('option was clicked');  });}

Now every time you click on any block you will get this alert message from the browser. That was easy! Now our options are receptive, and they are responding to user input. All we need to do now is define the logic that tells what happens if the color picked by the game and that chosen by the user are the same.

By now you may already have the solution if you have paid attention to the above parts carefully. So let’s see how we can do it.

Checking if the color is correct or not

Let’s explore the possibilities we have with our options/color boxes being receptive and responding back. We can conduct a small test and see if the two colors match or not. Very soon we will have randomly generated colors every time we refresh the page or every time we reset the game or change the mode of game. But for now, we will practice with the set of six RGB color codes we have assigned in the file.

Let’s look at some code and then I would break it down for you.

for(i=0; i<= squares.length; i++) {  squares[i].addeventListeners('click', function() {    //if correct block is clicked do something....    //if wrong block is clicked do something....  });}

As you already may know, we will be using a simple if-else block.

pickedColor = colors[3];for (i=0; i <= squares.length; i++) { //apply background colour to all the squares... squares[i].style.backgroundColor = colors[i]   //enable click event on each square.....     squares[i].addEventListener('click', function() {

       //if the user selected the right colour....         var clickedColor = this.style.backgroundColor;

        //check if the selected colour matches the default colour...

         if(pickedColor === clickedColor) {             changeColors(pickedColor);           }         //if the user user selected wrong colour....         else {           this.style.backgroundColor = "#232323";           messageDisplay.text = "Wrong Choice!";         }    })};

I know — it’s a lot of code. But let’s see what it really means:

• We start with defining what the default color picked by the game will be, with the variable pickedColour.
• Then we run our for loop which lets us go through the array of color blocks/options.
• Then we enable the click events on each and every color bock/option. We do this using a callback function. This function does nothing but select the background color of the selected color block/option simply by assigning it to the variable called clickedColour.
• Now we have both colors: one that was selected by the game and the other by the user. All that’s left is to match and see if the choice was correct or not.
• We can do this easily using the if else block. If the choice is correct, then do this, or else do something else
• If the correct color is selected, we add some text on the page to confirm the correct choice and add some visual effect to reconfirm. Else we match the color of that particular color option/block to match the background color of the page. This produces an effect as if the color block/option just disappeared.
• Now you have seen that if the same color is selected, then a function is executed. Let’s see what that function is made up of:

function changeColors(color) { for (i=0; i <= squares.length; i++) {  squares[i].style.backgroundColor = color;  messageDisplay.text = "You are good at guessing!"; }}

This function goes through the array of color blocks/options and resets the background color to be that of the selected color or the default color.

In case the colors are not the same, we simply set the current selection’s background color to be that of the webpage.

else {  this.style.backgroundColor = "#232323";  messageDisplay.text = "Wrong Choice!";}

Alright now that we have the main game set, we just need to worry about minimal design issues and adding the functionality into the control panel.

But first let’s look at what the code folder looks like at this point if you have followed all the steps correctly:

index.html

app.css

app.js

Step 3

All is well. But now we need to create new randomly generated RGB color codes in our game that are not the same set of colours that would be assigned in the color blocks/options.

If that makes you think about functions, then that’s the right choice. We will be creating a new function along with totally random (new) color codes, and we will assign them to the colors array. Then we’ll fetch them in the color blocks/options array.

Let’s see what the code looks like, and then we’ll go through it line by line.

A built-in method in JavaScript helps us generate a random number between 0 and 1. Then we make some manipulations to make sure that the range of that random number stays between the digits 0 and 255.

• First we implement Math.random, selecting any random number between 0 and 1, then multiply the number by 256 since we don’t want the number to be any bigger than 255. Once we have a random number, we use Math.floor and make sure that we only have the digit before the decimal values (a whole number).
• We assign these random numbers generated to variables called r, g, and b. Each signifies its own respective RGB number for the color code.
• Lastly, we add up all of these numbers or variables to form a string. We return the string so it looks something like this: rgb(23, 45, 112).
• All that’s left to do is to run this function depending on the mode of the game, and generate three or six random RGB color codes and assign them in the colors array.

But this will only return a string which looks like an RGB code. How will this be added to the array of colors we have? How will a random color be selected every time the game is started or reset?

To accomplish both of these things, we’ll create a couple of more functions and see how they help us solve this issue.

Select a random colour from the array

To do this, we will create a new function called pickColor(). Let’s see how the function will look, and then we will break it down.

function pickColor() {  var random = Math.floor(Math.random() * colors.length);  return colors[random];}

As simple as it can get, let’s see what these two powerful lines do for us.

• As we have already seen with the magic of Math.random and Math.floor, we use the same function to get a random number generated between 0 and the length of the array.
• Next, we get the corresponding RGB code in the colors array by using the random number in the index

Add six (or three) random RGB codes in the colors array

To do this, we use the above two functions, which are randomColors() and pickColors(). What the randomColors() function does in particular is that it runs the randomColors() function six or three times (depending on the mode of the game) and adds the corresponding number of RGB color codes to the colors array. We will name this generateRandomColor(num*) function. Let’s see how the code looks and break it down line by line.

*num will be decided on the basis of the mode of the game.

• First we’ll make a simple empty array
• Next we run a loop as per the mode of the game
• Every time this loop gets executed, a new RGB code is pushed into the array created
• At last we return this array

Now after all these new functions and all this code manipulation, our code base for app.js has changed quite a bit. Let’s see what it looks like now:

Reset Game

After almost setting up the primary logic, this may look like a cake walk. It’s all about creating a function and letting that function do its job against any given user input (in this case, a click of the reset button).

All we want with the reset button is

• generate a set of six random colors
• pick a random color out of the new created colors array.

Let’s see how the pseudo code would look:

function reset() {  //create a new array of 6 random colors  //pick new random color  //fill the squares with new set of generated colors}

I strongly recommend writing pseudo code while solving complex problems. This habit of writing pseudo code has helped me save a lot of time whenever I’m stuck on complex algorithmic challenges.

Alright, coming back to our reset button: let’s see how the actual function would look:

Let’s break it down line by line:

• We start with adding the event listener for the reset button. We then fire a callback function which does a bunch of things when the click event is fired.
• When it’s fired, we start by generating a new array of six random colors.
• Then we pick a random color.
• Lastly, we reset the background color for all the color blocks.

This is what the updated app.js looks like after all the edits we have made:

This looks pretty good for now! I am not adding the functionality for setting up the mode in this article, as it is already getting to big and I don’t want to bore you all :). But if you liked all of this, I will be more than happy to write another article covering the rest.

Here’s the link for the GitHub repository where the final optimized code can be found.

I hope this article inspires a few of you to learn more about DOM manipulation and this beautiful language of JavaScript. Until the next time!