‘Making the Top Down Shooter Game: Aviator’ Unity Game Manual

‘Making the Top Down Shooter Game: Aviator’ Unity Game Manual

1 and a half year ago, I made a game called Aviator. Then, I thought of writing its manual. And I recently checked my old stuff and realized that I should post it on my blog.

At that time, I was learning Unity and its basics so, I never know a lot of techniques that I know, now. (Seriously, it could have been much easier)

Anyhow, the manual is step by step guide to make the game. The only issue is that I never completed it!

That includes the Graphical User Interface (partially done), the basic Sprite Sheet animation, Music and Sound Effects.

Not a complete package and that is why I am giving it away for FREE!

I am not giving the Unity Game Project itself due to some reasons. But I am sharing all the resources that I used in the game including the music. All the resources are not created by me and so, don’t blame me if you get into some copyright issues with your game. I am sharing those resources for educational/learning purposes.

I hope that the manual will greatly help you.

Aviator Manual: Download Link

Aviator Resources: Download Link



My Vectors: First time making an Anime Face

My Vectors: First time making an Anime Face

Here is another vector drawing that I did on Inkscape.

It is my first time drawing an Anime kinda face. I tried to be as simple as possible. He is bald on the sides, thanks to my awesome drawing skills. 😀

Seriously, drawing cool hair is very daunting yet hard at the same time. But mine isn’t half bad. Or is it? Do comment below to let me know.

Shadows seems a little odd. I did some referencing but still couldn’t do much about them. It is just plain black on top which doesn’t seem to count as a good shadow. Maybe I shouldn’t blur it. Also, the placement of shadows could have been a lot better.

Did I say plain black? It did remind me of something. My new game! FALLINGbits. Please do check it out if you are an Android user.

Also, there are no highlights which makes the image pop out.

Please do suggest me what else you want to see me draw and post here. I am always open for suggestions and requests.

First Anime Face
First Anime Face

FALLINGbits: What is the status?

FALLINGbits: What is the status?


I can’t believe it man! Seriously, this is amazing.

I got a download!

Look at the image below! A download. Really, whoever he is, he made my day. Thanks to him.

FALLINGbits Status #1
FALLINGbits Status #1

Now, 9 more downloads in 20 more days. If you want to help me achieve this target, here is the link.

To those who are thinking:

Wha? This is nothing. Seems like that someone did an act of sympathy. 6 views! What a lowly molly it is….

And so on… Yeah, you are right.

I just wanted to see how things goes on. The real thing is yet to come.

The reason for such less views is probably because…

  1. I never considered doing marketing.
  2. Itch.io has probably smaller audience who would like to download a game and play it on there Android phone rather than just play it on web.
  3. My game runs on Android only. (again same reason)
  4. My game is not good enough. 😥
  5. I have not paid much attention to my blog.

I have been very busy dealing with multiple stuff. But I will not leave my blog again.

Stay tuned for more. And do check my game on itch.io (the link is given above).

FALLINGbits on Itch.io

FALLINGbits on Itch.io

My first ever published game… 😀

Here is the link.

itch.io makes it easy for anyone to publish games and many more stuff into the market. It is just an experiment to see how well things can go over there.

My target is to get, at least 10 downloads in 30 days span.

Thank you for making it possible.

FALLINGbits is a straight forward game. It can’t be any simpler.

Avoid bits.

Keep the finger on the screen.

If you remove the finger, the game will pause. Colliding with the bits (squares) will result in losing the game. A simple game worth playing.

It becomes super after 90000 score (90 seconds of playing one game).

Unfortunately, it is only for Android. File size is almost 1 MB only. You may face some issues if your device have the resolution of non-HD aspect ratio.

Some screenshots…


It is one of my old projects that I did with C++ and SDL2. I learned a lot during that time. Do tell me if you want some SDL2 tutorials here.

And yes, I didn’t forgot Doboomler and still working on it.

Try it. You may like the game. And if you do, don’t hesitate to comment!

C++ Programming Series: What’s next?

You wanted to get into game programming.

You found out that C++ is the real deal.

You came here and started reading the first post of the series.

You practiced and moved on till the end.

Now, you are confused what to do next?

(By the way, it applies to all the enthusiastic people who learned programming for the sake of making games.)

What you need to do now, is to google some simple C++ 2D Game Development Libraries.

Back in the days, SDL2 was my choice (I still use it a lot). SDL2 is pretty neat and it just clicked with me. But it does have drawbacks (for example, no easy-peasy shaders). If SDL2 is your choice, Lazy Foo’s SDL2 Tutorial Series is probably the best place for learning it. I also learned SDL2 from there.

People recommend SFML a lot. Even though I don’t use it, it won’t hurt you to try different libraries in the start and just go with what feels right.

Less features won’t hurt. But less personal compatibility will…

That is why I use SDL2. Even if there is not that something you need, you can craft your own hack to go through it.

Why not OpenGL library or just any library to make 3D games (like Call Of Duty and GTA)?


It’s impractical unless you got a thousand experienced people of all kinds working on it.


Why not a game engine like Unity for making 2D games?

Yeah, you can. In fact, it is awesome go and do it.

But you may consider this. They have a GUI, an editor and all fancy stuff that eases game development. And that makes your brain lazy and kinda limits your creativity.

I am not saying to built a game development career upon some C++ 2D Game Development Library (which honestly, won’t hurt). I am trying to imply the fact that doing code by hand and visualizing the game in the head will give you a much deeper understanding of what a video game is and how video game actually works.

And when you are satisfied with that experience, you can go with Unity like me.

How this deeper understanding thing works on a higher level?

It works. But you may not be able to see it working. Unconscious, maybe.

To see it in effect, just compare yourself with the one who went directly into Unity and you will realize yourself. You will be able to pick things faster than he would.

And please, take my words with a grain of salt.

So, that means I, as an individual, am stuck with 2D forever?

Hell no!

I recently started learning Blender (free, open-source 3D modelling and rigging software) and it seems like 3D is a viable option for any solo developer.

But yeah, as a solo game developer, no Call Of Duty or GTA forever. But awesome games like Gone Home and Inside are always a good option for any experienced artist and game developer.

In the end, I would like to say to make as many complete games as possible. With every completed game, your experience gets higher exponentially as compare to half-baked games.

Here is the summary:

Programming -> 2D in Game Library -> 2D in Game Engine -> 3D in Game Engine

What if I learned C++ for some other purpose?

Well, I don’t know the specifics but you can go for that purpose as hard as you can.

Sorry, I don’t have much advise on that, other than the fact that you shouldn’t go big on what ever the purpose is. Always try small and then, step towards bigger things.

C++ Programming Series: Dynamic Arrays (Part 2, Last)

Dynamic arrays can be used with functions in exactly the same way as I have told in this post. Just keep in mind that we have to pass the size of array into the function.

void printIntegerArray(int* pArr, int totalElements)
  for(int i = 0; i < totalElements; i++)
    cout << pArr[i] << endl;

int main()
  int* array = new int[5] { 3, 4, 7, 8, 12 };

  printIntegerArray(array, 5);

  return 0;

Note how I allocated the memory and also, set the value of all the elements in the dynamic array in the highlighted line.

That initialization of dynamic array is what the real purpose of this small post is. Why? Because dah! I learned that very late. Very very late.

At least, I am able to save others from this.

array[0] = 3;
array[1] = 4;
//...till the end :p

Also, there is another purpose of this post.

Tell me my mistake in the code.

If you already knew it before reaching this part, you must be a keen observer. There is no delete[] array; at the end of the code.

Damn those memory bees. (By the way, it is a genuine mistake)

This ends my C++ Programming Series. Now, to ease your path, there will be another post in this series. Keep coming back and you will always find bunch of useful stuff here.

C++ Programming Series: Dynamic Arrays (Part 1)

Before we get into the dynamic arrays, it is important to understand why we use them and when to use them.

Here’s the simplified concept of memory types.

The program that we execute stores and works with the data, information and variables (collectively called memory) in the RAM (Random Access Memory). Upon closing the program, it no longer remains there. Memory that remain saved even after a program is closed, is present in ROM (Read Only Memory). For example, the photos, text files and the program itself stored in the hard-drive.

Now, here’s the important bit. RAM is generally divided into two parts: Stack and Heap. Stack is the tiny amount of RAM that can be used by the program for quickly accessing the memory. When we make variables, the way we did in this series, we are saving this in it.

On the other hand, heap is the remaining big chuck of RAM that can be used by the program to work on large and uncertain amount of data.

The question that why this division exists? It is pretty straightforward. As stack is much smaller than heap, it is much faster to access the memory in stack than in heap. But stack has its limits as it is tiny in size which means that it is not supposed to have uncertain size of data and is not supposed to be holding onto something for indefinite period of time. Here comes into action, heap. Heap is there for that purpose: uncertain size of data and no time constraints.

There are multiple ways to store variables in heap. One of them is to simply define a variable above and outside the main function.

int iAmInHeap = 95;

int main()
  int iAmInStack = 5;

  return 0;

Functions outside the main function can be called global variables and they can be manipulated during execution from outside i.e they are not secure and it is not a good habit to make global variables.

At the ending curly bracket (i.e at the end of a block), the stack memory is destroyed and can not be used anymore. This is perhaps, what we call the scope of a variable. The very first post of this series might remind you what I meant here.

On the other hand, heap memory is destroyed only when you destroy it. But the variable it is stored in, is no longer accessible after the end of a block.

Alright, I have said so much. Now, let us get into the practical heap situation. To make a typical heap variable (that is not global variable), following is the code.

int main()
  int* typicalHeapVar = new int;
  *typicalHeapVar = 10;  

  delete typicalHeapVar;

  return 0;

Time to introduce a pair of keywords: new and delete. Before using dynamic arrays, always keep in mind that:

Where there is new, there is delete as well.

I have to use this kinda dramatic quote to remind myself of this very important thing. And that is because new allocates the memory and delete de-allocates the memory.

new without delete means memory leaks in the program. delete without new is not as bad because delete checks whether the pointer is NULL or not. So make a habit to set the pointer to NULL after deleting it.

But what about the practical heap situation? Lets say that we are making a program that blurs all the images in a folder. All the images! That is what uncertain size of data means.

We know that when we make an array, we can not use a variable to set the size of an array. Sure that we can have a limit to it like what I did below.

const int MAX_IMAGES = 100; //That is the limit of our program!

//Suppose that Image is a user defined structure.
Image images[MAX_IMAGES];

//We get the images from a folder with a function called getImagesFromFolder that gets all the images and saves them into the array of Image objects.
//It also returns the number of images present in that folder.
int noOfImages = getImagesFromFolder(images);

//Blur them all...
for(int i = 0; i < noOfImages; i++)
  //Suppose that... alright you get it already!

//Then, save them back...

You can point out 3 flaws with the program.

  • First one is that an image can be of any resolution and any size. Stack is used here to possibly store MB’s of image data. Not a good thing.
  • Second is again, the limit. What if the images are more than 100.
  • Third is the unnecessary use of memory. If the folder contains 10 images, there are still 90 useless array elements. It won’t effect the performance of the program but it will definitely shorten our already tiny stack.

Okay, maybe I am exaggerating. But it is to explain the benefits of using heap at such situations.

This is how it will look when we use dynamic arrays.

//No more limit variable

Image* images;

//First, we simply throw in a NULL pointer and get the total number of images in the folder.
int noOfImages = getImagesFromFolder(NULL);

//Then, we use this variable to tell us the amount of elements our array will have.
images = new Image[noOfImages];

//Then. we get the images from folder.

//Blur them all...
for(int i = 0; i < noOfImages; i++)
  //Suppose that... alright you get it already!

//Then, save them back...

delete[] images;

Now, you also know how to make dynamic arrays (not just typical heap variables).

My explanation maybe inaccurate and could have faults so, I suggest you to look around as well. As for the practical heap situation, I hope you got my point. The series is almost coming to an end.

Usually, people know all that. But they don’t know what is the right place to use them. I learned it the hard way. And I am still learning and prone to errors.