Building Flappy Bird #2 – Let’s Code
Building Flappy Bird in Unity3D – Part 2 – Let’s code
Code in Unity3D can be done in either C# or Javascript. If you don’t have a preference, I’d recommend C# for your development. It’s much more popular in the Unity3D community. Most samples you find will be in C# only. For this tutorial though, I’ll provide both the C# & Javascript versions.
Moving the Fish
If you’ve played Flappy Bird before, you know the bird flys to the right of your screen past a bunch of tubes. Or at least that’s what it looks like. In reality, the bird is just going up and down and the tubes are moving. So for our game, all we need the fish to do is go up when we tap the screen (or click the mouse).
First we need to create a folder for our code. In the root of the Project view, create a new folder named Code.
Project Code
In the Code folder, right click and create a new C# script.
Project Create CSharp Script
Name the new file “Fish”
Project View Fish CSharp File
If you need to re-name a script, just select it and hit F2.
Windows Only Section (Optional)
If you’re using Windows, I want you to switch your editor to Visual Studio now. You can use MonoDevelop (the default editor), but the benefits of using Visual Studio make me HIGHLY recommend it.
To switch to Visual Studio, select Edit->Preferences
Preferences Menu
Go to the External Tools section and set your External Script Editor to Visual Studio 2015.
Settings – Select Visual Studio
Back to our Code (Mac & Windows)
Now, double click the newly created Fish script.
You should be presented with a code file that looks like this.
using UnityEngine;
using System.Collections;
public class Fish : MonoBehaviour {
// Use this for initialization
void Start () {
}
// Update is called once per frame
void Update () {
}
}
In Unity3D, every Component on a GameObject must inherit from MonoBehavior. If you don’t know what this means, don’t worry, you’ll pick it up. What this means for us though is that our Fish script has some default functions we can hook into. You can see two of these functions in your code now.
- Start – Any code in here will be called when the GameObject is created in our game. If it was placed in the Hierarchy (like our fish will be), it’s called when the game starts.
- Update – Any code we place in here will be called once per Frame. In a typical game, we’ll have 30-90FPS (Frames per second). This means that the code here will get called 30-90 times per second.
InputManager
To move the fish, we’ll need to read the players Input. Because this is such a common thing to do, there’s a very simple way to get it.
Modify your Update function to look like this.
// Update is called once per frame
void Update () {
bool pressedFireButton = Input.GetButtonDown("Fire1");
if (pressedFireButton)
{
Rigidbody2D rigidbody = GetComponent<Rigidbody2D>();
rigidbody.velocity = Vector3.zero;
rigidbody.AddForce(Vector3.up * 1000);
}
}
Now let’s look at the code and see what it’s doing, line by line.
bool pressedFireButton = Input.GetButton("Fire1");
Here, we’re creating a new variable named pressedFireButton.
It’s type is bool – A bool variable can be either true or false.
We’re assigning it a value from our Input system by calling the GetButton method. The GetButton method takes one parameter which is the name of the button. We’re passing in the button name “Fire1” and the function will return True if we’ve pressed one of the inputs mapped to it.
Fire1 is a default button in Unity3D that is mapped to many things [Space, Left-Ctrl, Left Click, A button (Xbox), X button (PS), etc].
Checking Conditions
Next we have some conditional code. This line checks to see if the result of our input check was true. If so, the code following it in braces { } will be executed.
if (pressedFireButton)
{
... everything in here will execute
}
So if we have pressed the “Fire1” button (ex. tapped space), everything inside the braces will execute. This will only happen ONCE per press. You must release and re-press the button for the GetButton(“Fire1”) call to return true.
Handling Physics
The first thing we do inside the braces, is get the RigidBody2D component. This is the same component you added to the Fish earlier (when it started reacting to gravity).
Rigidbody2D rigidbody = GetComponent<Rigidbody2D>();
The properties we care about are X, Y, & Z. These are numeric values that represent a measurement on their corresponding axis.
We assign the RigidBody2D of our fish to the variable named “rigidbody”.
The “velocity” of our rigidbody is how fast it’s moving. It’s measured in a Vector3, which is just a simple data structure containing 3 values (and a couple calculated properties we’ll worry about later).
On the next line, we set the velocity of our rigidbody to Vector3.zero.
rigidbody.velocity = Vector3.zero;
Vector3.zero is just a shortcut to get a Vector3 with 0 for all 3 of it’s values.
This completely stops our rigidbody. If it was falling, going up, or in any other direction, this line of code stops it.
So setting the velocity of our rigidbody to Vector3.zero is setting the rate of movement to 0 in all directions.
Adding some Force
Next, we want to add some force and push our Fish upward.
rigidbody.AddForce(Vector3.up * 1000);
AddForce does exactly what the name says. It takes a single parameter, which is a Vector3. We pass in Vector3.up, which is just another shortcut to get a Vector3 pointing in the default upward direction. But before AddForce evaluates the Vector, we multiply it by 1000, so the resulting input is a Vector3 with the values [0, 1000, 0].
You may have already skipped ahead and tried it out. If not, get in the editor, hit play and try out our input handling. You should be able to click space, left-ctrl, or your mouse’s left-click. Notice how the fish STOPS, then gets force added. If we didn’t Stop the fish, you’d have to click very fast just to keep from falling.
It’s too much!
Fish flying too far
You may have noticed that the amount of force we’re adding is too much. Your fish is probably flying way off the top of the screen. We have a couple ways we could address this problem. The simplest is to just change that value of 1000 that we used earlier to something smaller. Go ahead and try that now. Make sure to SAVE the changed file or Unity3D won’t pick up your changes.
Another way to make these changes is to expose the multiplier we’re using in the Unity3D editor. Specifically, we’ll exposed it on the Fish component of the Inspector. To do this, we need to introduce a variable to our Fish class and add a special attribute to it so Unity3D knows we want to edit it.
Change your Fish.cs file to look like this. Bold parts show the changes.
using UnityEngine;
using System.Collections;
public class Fish : MonoBehaviour {
[SerializeField]
private float _upwardForceMultiplier = 100f;
// Use this for initialization
void Start () {
}
// Update is called once per frame
void Update () {
bool pressedFireButton = Input.GetButton("Fire1");
if (pressedFireButton)
{
Rigidbody2D rigidbody = GetComponent<Rigidbody2D>();
rigidbody.velocity = Vector3.zero;
rigidbody.AddForce(Vector3.up * _upwardForceMultiplier);
}
}
}
What we’ve done here is introduce “_upwardForceMultipler”. We’ve set the default value to 100f. The “f” on the end just signifies it’s a floating point value.
Most positional math in Unity3D and other game engines is done with floating point numbers.
Save the changes you’ve made here, then jump back to the editor.
Select the Fish.
You should now see an extra field in the Fish component that matches our variable name. If you don’t see the component, hit Play, then Stop. Playing forces a compile, which makes the engine update to your most changes.
Inspector – Upward Force Multiplier
Now we don’t have to change code to modify our force. We can simply adjust the number in here until we get a value we’re happy with. Go ahead and try it now. Make sure you’re NOT in PLAY mode when making the changes though.
Changes done while you’re in Play mode do not save. There are good reasons for this that we’ll cover later, but for now, just make sure you’re not playing when you make your changes (or they’ll be lost and you’ll have to do them again).
After a little trial and error, I ended up with 200 for my multiplier. If you have a different # that’s okay, go with something that feels right to you. You can always adjust this value later, and now that it’s in the Inspector, you can do it easily.
Continue to: Part 3 – Unity3D Physics & Collisions
We’ll add some Seaweed, learn about Physics & Collisions, and even kill a fish.
