When I first started teaching coding to kids, Flappy Bird was the game every student wanted to recreate. It’s easy to understand why – the game is simple yet challenging, addictive, and perfect for learning fundamental programming concepts. In my decade of experience as a coding instructor, I’ve found that creating a Flappy Bird game on Scratch is an ideal project for beginners who want to build something fun while developing their coding skills.
In this comprehensive guide, I’ll walk you through how to make a Flappy Bird game on Scratch from start to finish. By the end of this tutorial, you’ll have created your own version of this classic game that you can share with friends and the Scratch community. Let’s get started!
Before diving into the coding process, let’s understand what makes Flappy Bird such an iconic game. Created by Vietnamese developer Dong Nguyen in 2013, Flappy Bird became a worldwide phenomenon for its deceptively simple yet frustratingly difficult gameplay.
The premise is straightforward: players control a bird that must fly between rows of green pipes without touching them. The bird automatically falls due to gravity, and players must tap (or click) to make the bird flap its wings and gain height. The game ends when the bird collides with a pipe or the ground.
What makes Flappy Bird perfect for recreating in Scratch is that it incorporates several fundamental programming concepts:
I’ve found that students who complete a Flappy Bird project gain confidence in these concepts and are eager to apply them to more complex games.
To begin creating our Flappy Bird game, you’ll need to set up your Scratch environment. Scratch is a block-based visual programming language developed by MIT that makes coding accessible to beginners.
You have two options for using Scratch:
In my teaching experience, the online version is usually more convenient as it automatically saves your projects and allows for easy sharing. To get started:
If you’re completely new to Scratch, I recommend spending 15-20 minutes exploring the interface before continuing with this tutorial. Try dragging different blocks into the code area to see what they do.
Before writing any code, it’s important to plan your game. In my years of teaching game development, I’ve found that spending time planning saves hours of debugging later.
For our Flappy Bird game, we’ll need the following elements:
With this plan in mind, let’s start building our game step by step.
Every good game starts with setting up the proper environment. For our Flappy Bird game, we need a suitable background for the stage.
Alternatively, you can use the “Choose a Backdrop” button to select a pre-made backdrop from the library. Sky backgrounds work best for this game.
Next, let’s create our game variables:
Make sure to set the variables as “For all sprites” since they’ll be used throughout the game.
In my experience, proper variable naming is crucial for keeping your code organized, especially as your game becomes more complex.
[IMAGE 2: Side-by-side comparison showing the process of creating the bird sprite and its costumes]
Now, let’s create our main character – the bird:
For beginners, I recommend choosing a bird from the library and modifying it. If you want to be authentic to the original Flappy Bird, you can paint a simple, small yellow bird.
To make the bird more dynamic, let’s create two costumes to simulate flapping wings:
Having two costumes will allow us to animate the bird’s wings when it flaps. In my classroom, students really enjoy this part of the process – seeing their static character come to life with simple animation.
Now for the fun part – making our bird move! Select your bird sprite and add the following code in the “Code” tab:
when green flag clicked
go to x: [-50] y: [0]
set [gravity v] to [0.5]
set [speed v] to [0]
set [score v] to [0]
set [gameState v] to [playing]
forever
if <(gameState) = [playing]> then
change y by (speed)
change [speed v] by (gravity * -1)
if <key [space v] pressed?> then
set [speed v] to [8]
switch costume to [wings up v]
play sound [flap v]
else
switch costume to [wings down v]
end
if <touching [edge v]?> then
set [gameState v] to [over]
broadcast [game over v]
end
end
end
This code does several important things:
The gravity mechanic is particularly important in Flappy Bird. In my experience teaching this concept, I’ve found that students initially struggle with the idea of negative speed, so I make sure to explain how the speed variable represents the bird’s vertical velocity, which can be both positive (moving up) and negative (falling down).
[IMAGE 3: Screenshot showing the pipe sprites and their code blocks]
The next challenge is creating the pipes that our bird must navigate through:
Now, let’s program the pipes to move across the screen:
For the “Pipe Top” sprite, add this code:
when green flag clicked
hide
set size to [80] %
forever
if <(gameState) = [playing]> then
create clone of [myself v]
wait [1.5] seconds
end
end
when I start as a clone
go to x: [240] y: (pick random [0] to [100])
show
forever
if <(gameState) = [playing]> then
change x by [-5]
end
if <(x position) < [-240]> then
delete this clone
end
end
For the “Pipe Bottom” sprite, use similar code but adjust the y-position to ensure there’s a gap between the pipes:
when green flag clicked
hide
set size to [80] %
forever
if <(gameState) = [playing]> then
wait [1.5] seconds
create clone of [myself v]
end
end
when I start as a clone
go to x: [240] y: (pick random [-170] to [-70])
show
forever
if <(gameState) = [playing]> then
change x by [-5]
end
if <(x position) < [-240]> then
delete this clone
end
end
This code creates clones of the pipes that move from right to left across the screen. The random y-position creates varying heights for the pipes, making the game more challenging.
I’ve found that adjusting the pipe speed and spawn rate is crucial for balancing the game’s difficulty. Too fast, and the game becomes impossibly hard; too slow, and it loses its challenge. The values I’ve provided create a moderate difficulty that works well for beginners.
Now we need to program what happens when our bird hits a pipe. Add the following code to your bird sprite:
when green flag clicked
forever
if <touching [Pipe Top v]?> or <touching [Pipe Bottom v]?> then
set [gameState v] to [over]
broadcast [game over v]
end
end
This simple code checks if the bird is touching either pipe, and if so, ends the game by changing the game state and broadcasting a “game over” message.
Collision detection is often tricky for beginners to understand. I always explain to my students that this is essentially how the computer “knows” when objects interact with each other in the game world. It’s a fundamental concept that applies to virtually all types of games.
[IMAGE 4: Screenshot showing the score display and the code that increments it]
Every game needs a way to track progress, and in Flappy Bird, the score increases every time the bird successfully passes through a set of pipes.
Let’s create a scoring system by adding this code to the “Pipe Top” sprite:
when I start as a clone
wait until <(x position) < ([-50])>
if <(gameState) = [playing]> then
change [score v] by [1]
play sound [point v]
end
This code waits until the pipe has moved past the bird’s x-position, then increases the score by 1 and plays a sound effect.
To display the score, add this code to the stage:
when green flag clicked
forever
if <(gameState) = [playing]> then
say (join [Score: ] (score))
end
end
In my experience teaching game development, implementing a scoring system dramatically increases student engagement. There’s something deeply satisfying about seeing your score go up as you successfully navigate obstacles.
Sound effects make games much more engaging. Let’s add the following sounds to our Flappy Bird game:
Make sure the sounds are short and appropriate for the action they represent. In Scratch’s sound library, “Bird” works well for flapping, “Pop” for scoring points, and “Bonk” for collisions.
Now, update your code to play these sounds at the appropriate times. For example, add this to your bird’s collision detection code:
when green flag clicked
forever
if <touching [Pipe Top v]?> or <touching [Pipe Bottom v]?> then
play sound [hit v]
set [gameState v] to [over]
broadcast [game over v]
end
end
In my teaching experience, sound effects are one of the easiest ways to make a game feel more professional and engaging. They provide immediate feedback to the player and make the game world feel more alive.
When the game ends, it’s important to provide clear feedback to the player and give them an option to restart. Let’s create a game over screen:
Now, add this code to the “Game Over” sprite:
when green flag clicked
hide
when I receive [game over v]
go to x: [0] y: [0]
show
when this sprite clicked
broadcast [restart v]
hide
And add this code to the bird sprite to handle the restart:
when I receive [restart v]
go to x: [-50] y: [0]
set [speed v] to [0]
set [score v] to [0]
set [gameState v] to [playing]
Also, add similar restart code to the pipe sprites to clear any existing clones when the game restarts.
A proper game over screen helps create a complete game loop, which is essential for a polished gaming experience. In my classes, I encourage students to customize their game over screens with personal touches like congratulatory messages or fun facts about their high scores.
[IMAGE 5: Before and after screenshots showing the game with visual enhancements]
Now that we have the core gameplay working, let’s add some polish to make our game more appealing:
Here’s a simple example of code for a scrolling background:
when green flag clicked
go to x: [0] y: [0]
forever
if <(gameState) = [playing]> then
change x by [-2]
if <(x position) < [-480]> then
set x to [480]
end
end
end
These polish elements may seem small, but in my experience, they make a huge difference in how professional and complete your game feels. Students often get extremely excited when adding these finishing touches because they see their project transforming from a basic prototype to something that looks and feels like a “real” game.
Before sharing your game, it’s important to thoroughly test it to catch any bugs or issues. Here’s a testing checklist I’ve developed for my students:
When you find issues, fix them one at a time and test again. Debugging is an essential skill for any programmer, and creating games is an excellent way to develop this skill.
In my years of teaching Scratch programming, I’ve encountered several common issues with Flappy Bird games. Here are some troubleshooting tips:
Issue 1: The bird moves too fast or too slow
Issue 2: Pipes are too difficult to navigate
Issue 3: Score doesn’t increase properly
Issue 4: Game doesn’t restart correctly
Issue 5: Collision detection seems inaccurate
Remember, troubleshooting is an integral part of the programming process. In my classroom, I encourage students to see bugs not as failures but as puzzles to be solved.
Once you’ve created a basic Flappy Bird game, you might want to add some advanced features to make it more unique and engaging:
In my experience teaching game development, these advanced features are where students really get to express their creativity and make the game their own. I’ve seen incredible variations of Flappy Bird, from space-themed versions to underwater adventures, all built on the same fundamental mechanics we’ve covered in this tutorial.
Congratulations! You’ve learned how to make a Flappy Bird game on Scratch. We’ve covered everything from setting up the basic game environment to adding advanced features and polishing touches.
Creating a Flappy Bird game is an excellent way to learn fundamental programming concepts like conditionals, loops, variables, and collision detection. These skills form the foundation for more complex game development projects.
I encourage you to experiment with your own unique ideas and themes. The most successful games are those that bring something new to the table while building on established mechanics. Share your creation with the Scratch community, get feedback, and continue to refine your game.
Remember, game development is an iterative process. Don’t be discouraged if your first attempt isn’t perfect – each version you create will be better than the last. As I tell my students, the most important thing is to have fun with the process and learn along the way.
Happy coding, and I can’t wait to see what amazing games you create!
Want to learn more about Scratch coding? Check out our other tutorials:
Want your child to go further? Explore ItsMyBot’s Little Coder — structured coding courses designed for kids!