I’ve been working on a new game for the past few weeks, currently called Zombie Barrel Blast. It originally started as a little physics test after watching some Donkey Kong Country videos on YouTube, to see how much of it I could recreate. I started adding barrels, and making physics effects with them and before I knew it, I was having so much fun blasting myself from one barrel to the next I decided to make an entire game out of it!

With that, the development for Zombie Barrel Blast was born.

The concept is simple. There are barrels and you have to blast your zombie forward from one to the next, without dying. Just like the barrel mini-games in the DKC series. There are plenty of obstacles along the way – so beware! You’ll have to think strategically to land your shots without falling off a cliff.

The game should also contain two main modes of play. The first will be your standard infinite scroller experience, with increasing difficulty the further into the level you get. This mode will also have Google Play leaderboards so you can compete against other players to see how far you can get.

The second mode will be a series of levels, offering unique challenges, where you can try to earn three stars for each one. Each level will have a different goal so you’ll have to constantly adapt how you play in order to succeed.

Anyway, that’s what I have going on for now. Stay tuned for further updates. Let me know if you have any questions or thoughts in the comments!

If you would like to check it out, visit this page to learn more about Zombie Barrel Blast.

In the previous post we made our Tetris clone pieces fall on their own. Now, we want to allow our player to tell the pieces when they are going to move left and right. In addition, they should also not be able to move the pieces left or right, outside of the play space. How can we move game pieces via player input?

The first thing you should do is familiarize yourself with the commands that will be necessary to actually register player input. There are three similar commands to accomplish this. These are:

• Input.GetKeyDown()
• Input.GetKey()
• Input.GetKeyUp()

How are these different? Input.GetKeyDown() will recognize the first time a key is pressed, and then you will have to press the key again each time you want to call it. Input.GetKey() will allow you to hold a key down and have it register multiple times. Input.GetKeyUp will, as you may have guessed, recognize when a key is released.

We will be using Input.GetKeyDown().

Within the Update() method, you will need to write an “if” statement to register key input. One if statement will be used for moving the piece left, and the other for moving it right.

Within the “if” statement, you can use the double vertical lines to signify “or.”

While the above code will make your pieces move left and right, they will be able to continuously do so, into infinity. Obviously, we don’t want them to move more than 10 blocks to the right.

Also, consider that different pieces are going to have different widths. Each piece can be anywhere from one to four blocks wide, which means that it would be helpful to always know where their left and right sides are. That way, we don’t move the pieces outside of the play size, either by their left or right.

Fortunately, there is a relatively simple way to do this.

The first step is to go to your game piece and add a new component, one called a Box Collider 2D.

Once this has been added, we can access it to do some calculations, which will help us find the edge of the piece. The Box Collider 2D contains information on the center of the object it’s attached to, as well as it’s size. We can access this information by creating a new float variable and storing the data within the float. To do this, we type:

float pieceCenter = GetComponent ().bounds.center.x;
float pieceHalfSize = GetComponent ().size.x / 2;

pieceCenter now knows the center position of the game piece. pieceHalfSize is half the width of the game piece. Now, to find out the left and right edges, all we have to do is add or subtract the two, and store the results in new float variables.

float pieceRightX = pieceCenter + pieceHalfSize;
float pieceLeftX = pieceCenter – pieceHalfSize;

Of course, since we’ve been dealing in integers this whole time, it would be a lot more helpful if we guaranteed our game piece’s left and right sides rounded down to the nearest integer. We can ensure this happens by instead, typing the following code:

float pieceRightX = Mathf.Floor(pieceCenter + pieceHalfSize);
float pieceLeftX = Mathf.Floor (pieceCenter – pieceHalfSize);

Now, if you put your pieceRightX and pieceLeftX variables into a print statement and run the game, you should see that you get the left and right edges, in nice, clear whole numbers.

Finally, we can contain our Input if statements into one more if statement, ensuring they do not move outside of the game’s play space.

This is how to move game pieces via player input, and contain them to the game space at the same time.

If you have any questions, please leave a comment. Also, don’t forget to watch the video at the top of the post for extra clarification.

So far we have created an awesome looking user interface (UI) for our Tetris clone, so now it’s time to take the plunge and write our very first script. To do this, we are going to be creating a C# script and then writing code using Monodevelop. However, if you prefer, you can also use Microsoft Visual Basic to achieve the same purpose.

If you have never coded before, don’t worry, everything will be explained along the way.

Before we actually start coding however, let’s think about what our goals are for how to move game pieces through code. For this type of game, there are six immediate ones which come to mind.

1. Pieces should fall at a constant speed, which increases as levels get higher.
2. The player can move the piece left and right within the confines of the game.
3. The piece will stop when it hits the bottom or another piece.
4. The player can rotate the pieces clockwise and counter-clockwise in 90 degree increments.
5. There will be a small grace period when a piece lands where the player can still rotate it.
6. Pieces will never leave the confines of the game space.

This sounds a lot like a real Tetris game. Now let’s get into our bit of how to move game pieces through code. The very first thing you need to do is create a new C# script and attach it to your Tetris game object. Once you have done that,  take a look at the screenshot of a new script below and become familiar with what these parts are.

• The “using” statements at the top give us access to certain bits of code. Don’t worry about these for now.
• “Public class GamePiece” is essentially the name and description of our script. Think of it like the “My Documents” folder on your computer.
• MonoBehaviour gives us access to a lot of code. Don’t worry about this for now, just accept that you need it there.
• These squiggly brackets {} are like the file folders on a computer, but in this case they contain code.
• The grey text with // behind it are comments. We can use this to write comments in plain English and help us remember why certain things are there.
• void Start() and void Update() are methods. These are where we write our code. Whatever is written within Start() gets called when your scene loads and whatever is within Update() gets called every frame while the script is active within our game scene.

Now that you know what these things are, let’s talk about how to actually write our first bit of code. We are going to write a method called MakeBlockFall() and within it change the transform.position of the game object our script is attached to. As long as you correctly attached your C# script to a Tetris piece in the game scene, this should work.

The code we want to write looks like this:

transform.position -= new Vector3 (0, 1, 0);

transform.position contains the x, y and z coordinate of our piece. We write -= to subtract the value on the right side from the value on the left. Because we are dealing with 3 coordinates (x, y, z) we need to create and subtract a new Vector3() variable which also contains 3 coordinates. As we want to make our pieces move downwards vertically, this means we leave the x and z alone, and subtract 1 from the Y.

Next, we need to call our MakeBlockFall() method from the Start() method. To do this, we simply write the name of the method with the () at the end, followed by a semicolon.

By now, your code should look like this:

Go to Unity and press the play button to test your game out. When the game starts, your piece should go down by one world unit. It will happen instantly so you won’t see it, but trust that it has. Of course, we need it to move down more than one world unit. We need it to fall at a constant pace.

To achieve this, we will use InvokeRepeating(). This will allow us to call a method over and over for as long as we want. First, we will declare a new float variable that will be our fallSpeed. This is how often InvokeRepeating will get called in seconds. To do this, write at the top of your script, just underneath “public class GamePiece”:

public float fallSpeed = 1f;

• public determines what access level our variable has. The other option is to write private. By setting it to public we can change it from within the Unity inspector, without even entering Monodevelop.
• float is the type of variable we are assigning. Float variables use decimal places.
• fallSpeed is the name of variable. We can name this anything we want, but notice that the second word begins with an uppercase letter and the first word doesn’t.
• = 1f; is the default value we are assigning it.

Now, instead of writing MakePieceFall() in the Start() method, we will write the following:

InvokeRepeating (“MakeBlockFall”, 0f, fallSpeed);

This will allow us to call MakeBlockFall() every 1 second. Of course, we want the piece to stop when it gets to the bottom so under update we will write an if statement:

if (transform.position.y == 0) {
     CancelInvoke (“MakeBlockFall”);
}

Your code should now look like this:

Try it out and you should have a Tetris piece that falls and stops when it gets to the bottom of the level! This is how to move game pieces through code… or at least it’s the first step.

In the previous blog post we introduced our free Tetris clone and talked about how to find and import game assets. I also created a free enhanced Tetris starter pack that gives you most of the game assets you will need to get your game started.

In this blog post and video, you are going to learn how to create a Tetris grid that will allow you to easily and seamlessly place and move your Tetris pieces.

In this entry, we are going to take the first steps towards creating our Tetris clone, which means creating a game grid. Ultimately, we want to create something that looks like this:

The idea here is that we have a 10 x 22 Tetris grid. The Tetris pieces will have a pivot point in the bottom left corner. That means we want to get our game to a point where if we set both the X and Y coordinates of any given Tetris piece, they will appear in the bottom-left corner of the grid. Setting it to 9 and 21 would put the bottom-left corner in the upper-right most square. Remember, Unity starts counting at 0. So this means a 10 x 22 grid will be counted as 0-9 and 0-21.

Also, for this game we will be using a 1440 x 2560 game size, which is the same screen size as the Samsung Galaxy S7

The first step is to make sure our Tetris pieces are exactly 1 Unity world unit in both width and height. If you’re using the pack I provided, you’ll find that they import at a size that’s too small. In order to fix this, you will have to set their pixels per unit to 43.

Next, you will want to make sure the Tetris pieces are set to “multiple” and that you have sliced them with an automatic setting and changed their pivot point to “bottom-left.” This can be done by clicking the “Sprite Editor” button on the Tetris pieces inspector view.

Once this has been done, test that it’s working by dragging and dropping one of the Tetris pieces into the game scene and changing it’s X and Y position a rounded whole number. If the piece matches up to the Unity grid, it’s working properly. Now we can create a visual grid that will allow us to actually see how our pieces line-up.

Now that the Tetris pieces are in place, it’s time to create a grid system. The goal here is to create a grid that perfectly matches one Unity world unit for each grid block, in both length and height. In order to do this, we need to create a raw image. You can do this by clicking “GameObject” in the top window and then adding it from under UI –> Raw Image. Make sure you don’t choose just “image” or else this won’t work.

Once you have a raw image added to the scene, rename it “Grid” and attach one of the grid pieces from my enhanced starter pack. If you are unable to drag and drop the grid object onto the Raw Image, make sure you have changed the grid’s texture type to “Default” first. While you’re at it, make sure its wrap mode is set to “Repeat.” See the screenshot below for a visual.

Now… it’s time to get a bit mathematical.

If you think about the way an actual Tetris game is laid out, you will realize there is room on either side of the screen for UI elements. Because of this, we want our game’s play space to be roughly 70% of the actual screen size. That means we want our Tetris grid’s end result by the end of this article to look something like this:

In the above screenshot, you can see that the Tetris grid takes up 70% of the screen, leaving plenty of room on all sides for UI elements. How do we achieve this mathematically?

If you recall, our game’s screen size is set for 1440 x 2560 pixels. If we multiply these numbers by 70% (0.7) we get 1008 x 1792. This is what we will set our grid’s Rect Transform to be. We also want it’s Pos X, Pos Y and Pos Z to be set as 0. We will also set the UV Rect settings to W: 10 and H: 22, ensuring the grid sprite’s wrap mode is set to “Repeat.” The inspector for the grid should look like this:

Next, we will set the grid’s Canvas to be a “World Space” canvas, which allows us to manually manipulate it’s size.  However, with a default scale of 1, the canvas is HUGE. We will need to use a multiplier to scale it’s width and height appropriately. We can get this multiplier by dividing the number of Unity world unit’s desired (10 x 22) by the grid’s size (1008 x 1792). In other words, to get our multiplier, we do the following:

10 / 1008 = 0.00992
22 / 1792 = 0.012276

If we set those decimal numbers to the canvas’s X and Y scale, we should get a canvas with the appropriate size for our game.

Now, all you have to do is is move the canvas over so the bottom-left grid quadrant lines up with (0, 0). To achieve this, simply change the X position of the canvas to “5” and the Y to “11.” If you’ve followed all the other steps correctly, you should wind up with a grid that looks like the one at the start of this post! Also, just increase the size of the camera and change it’s transform to 5 and 11 as well.

Questions? Don’t forget to watch the accompanying video at the top of this post. But feel free to leave a comment below.

In this series of blog posts and videos we are going to be moving step-by-step, helping you learn to code by creating a free Tetris clone. This will be a working version of the popular game that has been around for generations.

Throughout these videos you will learn to code by designing this game from scratch using Unity as the game engine, and C# as the coding language.  In detail, here is what will be covered:

• You will create a Tetris clone that will be playable on the web or on smartphones.
• The game will have controls that are optimized for each platform.
• This will be a beginner – intermediate level. Can follow as a beginner if you are devoted.

This means that while the course will be easier to follow if you are not completely new to programming, it will be designed in a way that will allow you to follow along even if you are brand new. Although in this case, you may not quite understand everything at first. That’s okay! You can always go over the videos more than once and rewatch them again in the future after you gain more experience.

To get started, you will need a few things.

1. You will need to download and install Unity (free)
2. You will need to get the required game assets

I have provided a basic starter pack and an enhanced starter pack. The basic pack contains generic Tetris pieces and a simple grid texture. You can download this for free, below, with no strings attached.

The enhanced starter pack contains everything in the basic pack, plus more 3D looking Tetris icons, plus a full GUI (graphical user interface), on-screen sprites for controls, button sprites, royalty free fonts, plus a few sound effects. I have also included the .psd Photoshop files so you can edit the Tetris sprites yourself. This is also free to download, but to get access to the file you will need to sign-up for my mailing list.

Either way, you can find all the assets you need online on websites like dafont.com, opengameart.org and freesound.org. Or you can design them yourself.

Particularly if you’re new to programming, you’ll probably see a lot of parsing errors and unexpected symbol errors. Fortunately, while irritating to see, they are among some of the easiest programming errors to solve. Here is how to fix parsing errors and unexpected symbol errors in Unity, C#, and pretty much all other forms of programming.

In layman’s terms, parsing errors and unexpected symbol errors mean you have either added or omitted extra syntax. Usually, it can be traced to one of three things:

1.  You have added or removed an extra semicolon – ;
2. You have added or removed an extra parenthesis – ()
3. You have added or removed an extra squiggly parenthesis {}

There are other reasons why this particular error may occur, such as incorrectly using operations like greater than, less than, or adding or subtracting variable values. However, it’s more likely the source of your error can be traced to one of the above reasons.

Having just one too many or few of any of these can throw your entire script out of whack. Like Goldilocks and the Three Bears, it has to be juuuuuuuuuuuuust right.

So how can you quickly catch and detect these errors?

A console error message in Unity

The easiest way to fix a parsing error or unexpected symbol error is simply to double-click on the error message as it appears in the console. This will take you directly to the portion of the code giving you a problem.

For instance, if I were to double-click on the error message from the above screenshot, it would take me to line 27 in Monodevelop, which has “DontDestroyOnLoad” highlighted with a red squiggly line.

The error in Monodevelop

There is nothing wrong with this line of code, however, if you look directly above, you will see there is no semicolon after instance = this. Once a semicolon is added, the problem is solved!

Another very simple way of detecting and fixing a parsing error or unexpected symbol error is to press CTRL+F while in Monodevelop, and search for missing syntax. This can be particularly helpful if you have multiple errors or are dealing with a larger script.

Take a look at the sample code I’ve pasted below. As a challenge, use CTRL+F to see if you can detect the errors within. As a hint, I’ve created two errors. In one instance, I’ve added something extra, and in another, I’ve omitted something. See if you can figure out what’s wrong.

Did you figure it out?

If not – here’s the answer. On line 23 there is an extra ) bracket after if (instance != null));

The second error is a bit trickier to spot, but there is no closing squiggly bracket } for the if statement on line 40.

Using CTRL+F and checking individually to see if there are an equal number of brackets, these errors would not be too difficult to catch.

Hopefully, this information gives you a better idea of how to catch and fix parsing errors and unexpected symbol errors on your own. If you still need help, check out our sample video below, which will guide you through all of this in detail.

In this article, you are going to learn how to pass variables between scripts in C# and in Unity. This is highly common and extremely important so it’s a fantastic idea to get a solid grasp of this concept as early on as possible in your programming career.

In this example, what we want to do is drop a ball onto a paddle, and increment the score text in the upper-right corner of the screen by 100 points every time the ball bounces.

Easy enough, right? Let’s take a look at the code and how we can do this by passing variables. Before we do that, let’s take a look at what we have in our scene:

1. On the paddle, we have a C# script called Paddle.cs.
2. On an empty GameObject called Gameplay Controller, we have a script called GameplayController.cs
3. We have an empty text element called “ScoreText” without any scripts attached.

We want the paddle (which contains the score value) to tell the Gameplay Controller to add 100 points to the Score Text whenever the ball bounces off the paddle.

Inside Paddle.cs, we write a new function to register a collision. It looks like this:

OnCollisionEnter2D is the name of the function we write to register a new collision. It takes in a “Collision2D’ which we have assigned the name “collision.” Inside of this variable named “collision” is all the data surrounding the collision which has just occurred.

Next, we write the following inside of our GameplayManager.cs script:

Let’s go over this line-by-line and explain what is happening.

• We declare two variables; one is a Text variable called scoreText. This has been made public and in the Unity Inspector, we drag the text element onto that variable.
• The other variable is called currentScore. It is an integer and it is what we use to keep track of our game’s score.
• Next, we have declared a public function named UpdateScore. We have made it public so we can call it from another script (in this case, our Paddle.cs). Inside the brackets, we have declared a new variable “int score.” This is the “receiving” end of passing variables.

• When we call UpdateScore from our paddle script, we are going to “pass” the value of our score variable to the GameplayController.cs script. score is the name of the variable that is going to receive the value.

Now that we’ve created this, let’s go back to Paddle.cs and finish the script. Here’s what the rest of it will look like:

Now, we have created a score variable in Paddle.cs and assigned it an inital value of 100 points. We have then obtained a reference to our GameplayManager script, and finally, we call the UpdateScore method by writing gameplayManager.UpdateScore (score);

This last bit is very important. This is the other part of passing a variable between scripts. In the brackets we have written “score,” which is the name of the variable that passes the data contained within “score” (100 points). In GameplayManager, we have declared a separate variable, also named “score” (but it could be called anything we want) to catch and use that data within GameplayManager.cs.

This is how we pass variables between scripts.

Still confused? Check out the video below which goes hand-in-hand with this tutorial. Questions or comments? Please leave one below! We will get back to you