Android is a Linux-based operating system, which makes it open source software distributed under the Apache License Agreement by Google Inc. Due to its open source nature, other phone vendors have started porting the Android operating system on their newly created phones, which contributed to a very varied smartphone market for consumers. Starting from the first version of Android, this operating system has gained a good level of maturity, making it more reliable, secure, and stable operating system for smartphones. Let's have a look on some popular versions of Android in the next section.

Year by year, Android has increased its maturity level with each new version. Every version introduced new set of features from the user interface to customizations to flexibility to security. In terms of names, these versions are based on names of candy, chocolates, and other sweet stuff, such as Kitkat, Lollipop, and Marshmallow, but that's what makes Android a little more understandable to consumers and developers as well.

The following table highlights the main features of the different Android versions with their API levels as well:

The table only shows the changes made by Android operating system's developer, Google Inc. But due to Android's open source nature, other mobile manufacturing companies have also changed and introduced new features and modifications into Android. For example, Samsung has made a custom touch interface called TouchWiz, and HTC has made a custom user interface called HTC Sense. Similarly, Sony has introduced a custom user interface called TimeScape.

After the introduction of smart phones, the concept of market store came to existence in software technology, which revolutionized the mobile development industry. A significant role was played by Google Play in that revolution of mobile apps and games. Google Play is the largest market store in smartphones, with more than 2.2 million Android apps, games, books, music, shows, and more. These apps and games have been downloaded more than 50 billion times up to this point, and that marks a huge milestone achieved by Google in just 8 years of Android. You can check out Google Play at http://play.google.com.

A game engine is a software framework designed for the creation and development of video games. Many tools and frameworks are available for game designers and developers to code a game quickly and easily without building from the ground up. As time passed by, game engines have become more mature and easy for developers, with feature-rich environments. Starting from native code frameworks for Android such as Unity, Unreal, Cocos2D-x, LibGDX , and so on, the game engines started providing clean user interfaces and drag-drop functionalities to make game development easier for developers. These engines include lots of the tools which are different in user interface, features, porting, and many more things but all have one thing in common; that is they create video games at the end.

We will discuss some of the most popular game engines in this section by comparing those on the basis of:

• User Interface and environment like how easy it is to learn and develop games.
• Features and functionality like what game engine can achieve and do and on what level of quality.
• Pricing like is it free or paid.

Let's get into more details with this comparison.

Unreal Engine (http://www.unrealengine.com) is a game engine developed by Epic Games. It was an in-house game engine of Epic Games and was first showcased in 1998 first person shooter game Unreal. Unreal Engine is mostly used for creating first-person or third-person shooter games but it has also shown quite good quality in other genres such as stealth, MMORPGs etc. Unreal Engine includes high degree of portability and easy interface features with more logic and behaviors written in C++ language.

The latest release called as Unreal Engine 4 supports almost all platforms supported by Unity including Windows, Xbox One, Windows RT, OS X, Linux, PlayStation 4, iOS, Android, Ouya, and browsers using WebGL.

Unreal Engine 4 was released in March 2014 for the public use. Unreal Engine has nice user interface and navigation controls are very polished and easy to use. Unreal Engine provides very easy flow and interface to create first person shooter games and contains features to produce AAA quality game including real-time global illumination using voxel cone tracing, eliminating pre-computed lighting.

You can download the engine and use it for everything from game development, education, architecture, and visualization to VR, film and animation. When you ship a game or application, you pay a 5% royalty on gross revenue after the first $3,000 per product, per quarter Unreal Engine's learning curve is a little high so it's not best suited for new aspiring game developers:

Adobe Flash (formerly called as Macromedia Flash) (http://www.adobe.com) is a multimedia and software platform used for creating vector graphics, animations, games, and rich internet applications (RIAs) that can be viewed, played, and executed in Adobe Flash Player. The Flash is widely used for creating animations and mostly advertisements for web browsers but its use of creating games is declined very heavily in recent years by HTML5 framework.

There was a time when Adobe Flash was most popular game engine for online browser games and made a quite big wave of independent game developers creating games for online portals such as Kongregate and Miniclip.

The Adobe Flash includes very easy interface to create amazing and robust animations allowing artists to create vector art directly in the editor. It also supports Adobe Illustrator and Adobe Photoshop layers as well to make it easy integrated with vector art and animations. Adobe Flash allowed developers to port their games and animations from browsers to Desktops (Mac and Windows), Android, and iOS using Adobe AIR framework but couldn't grasp the much attention of game developers and artists due to low performance on end devices.

Adobe Flash has a Free 30-day trial but once the trial is finished you must buy a license unlike other engines discussed in this section.

Game Maker Studio (originally names Animo and later Game Maker) is an event-driven game creation system created by Mark Overmars in Delphi programming language in 1999. Originally created for 2D animations, it quickly moved up high on to being a very robust and easy-to-use drag-drop tool for creating 2D games.

Game Maker Studio uses pre-defined events to create actions in the game, which makes it very easy for developers to create games without needing prior knowledge of programming and coding stuff. The tool comes with a sandboxed language called Game Maker Language (GML), which allows developers to define custom and more complex behaviors for their games.

The Game Maker Studio comes with a clean and slick user interface that lets developers build and deploy their games on Windows, macOS X, Ubuntu, HTML5, Android, iOS, Windows Phone 8, and Tizen. The latest version also introduced Xbox One and PlayStation deployment.

Unity (http://unity3d.com) is cross-platform game engine developed by Unity Technologies. It made its first public announcement at Apple's Worldwide Developers Conference in 2005 and supported only game development for Mac OS, but since then it has been extended to target more than 15 platforms for desktop, mobile, and consoles. It is notable for its one-click ability to port games on multiple platforms, including BlackBerry 10, Windows Phone 10, Windows 10, OS X, Linux, Android, iOS, Unity Web Player (including Facebook), Adobe Flash, PlayStation 3, PlayStation 4, PlayStation Vita, Xbox 360, Xbox One, Wii U, and Wii.

Unity has a fantastic interface that lets the developers manage the project really efficiently from the get-go. It has nice drag-drop functionality with connecting behavior scripts written in C# and Boo (a dialect of JavaScript) to define the custom logic and functionality with visual objects quite easily. Unity has been proven quite easy to learn for the new developers who are just starting out with game development and now more large studios have also started it using, and that is also for good reasons.

Unity is one of those engines that provides support for both 2D and 3D games without putting developers in trouble and confusion. It has vast collection of online tutorials, great documentation, and a very helpful community of developers. Also, Unity has the Asset Store, where developers sell reusable components of Unity to reduce the development time and efforts for other developers. You can check Unity Asset Store at http://assetstore.unity3d.com.

Unity Plus and Pro are available for a fee, and Unity Personal has no fee; it is available any use to individuals or companies with less than US $100,000 of annual gross revenue. For more information, visit the Unity store at https://store.unity.com/:

Unity is a game development ecosystem of powerful rendering engine, intuitive tools, rapid workflows for 2D and 3D games, all-in-one deployment support, and thousands of already created free and paid assets with a helpful developers community. The feature list includes the following:

• Easy workflow, allowing developers to rapidly assemble scenes in an intuitive editor workspace
• Quality game creation, such as AAA visuals, high-definition audio, and full-throttle action, without any glitches on screen
• Dedicated tools for both 2D and 3D game creation with shared conventions to make it easy for developers
• A very unique and flexible animation system to create natural animations in very less time
• Smooth frame rate with reliable performance on all the platforms developers publish their games
• One-click ability to deploy to all platforms from desktops to browsers to mobiles to consoles, within minutes
• Reduce the time of development by using already created reusable assets available on the huge Asset Store

In summary, compared to other game engines Unity is developer-friendly, easy to use, free for independent developers, and feature-rich game engine. In next section, we will see some amazing features of Unity3D.

Before delving into the details of Unity3D and game development concepts, let's have a look at some of the basics of Unity 5.6 We will go through the unity interface, menu items, using assets, creating scenes, and publishing builds.

When you first time launch Unity 5.6, you will be presented with an editor containing a few panels on left, right, and bottom of the screen. There's nothing to worry from these panels. The following image shows the editor interface when it's first launched:

First of all, take the time to look over the editor and become a little familiar with it. The Unity editor is divided into different small panels and views that can be dragged around, resulting in a workspace that can be customized, according to the developer/designer's needs. Unity 5 comes with some pre-built workspace layout templates that can be selected from Layout drop-down menu in the top-right corner of the screen, as shown the following screenshot:

The layout currently displayed in the editor is the Default layout. You can select these layouts and see how the editor's interface changes and how different panels are placed in different positions in each layout. This book uses the 2 by 3 workspace layout for the game. 

The following screenshot shows the 2 by 3 workspace with the names of the views and panels highlighted:

As you can see in the preceding screenshot, Unity editor contains different views and panels. Every panel and view has a specific purpose, which is described in the following section.

Scene View is the whole stage for the game development, and it contains every asset in the game from a tiny point to any heavy 3D model. Scene View is used to select and position environments, characters, enemies, the player, camera, and all other objects that can be placed on the stage for the game. All those objects, which can be placed and shown in the game, are called as GameObjects. The scene view allows developers to manipulate game objects such as selecting, scaling, rotating, deleting, and moving. In simple words, Scene View is the interactive sandbox for the developers and designers. The Scene View provides some controls, such as navigation and transformation.

While developing games in Unity, you will place lots of game objects in the scene and their position, scale, and rotations, collectively called as transforms, are managed by transform tools. The following screenshot shows the transform tools:

You can select any selected transform action from this toolbar and change the game object accordingly. The following figure shows the gizmo on the selected game object when a transform tool is selected:

These tools do exactly the same job as their names suggest; move for translation, rotate for rotation, and scale for scaling. The Rect tool on other side was introduced in Unity 4.3 when Unity got native 2D support and tools. This tool is only for 2D sprite objects for their position, scale, and rotations. You can also select these tools with keyboard shortcuts.

In the last section, we discussed how GameObjects can be transformed and navigated in the scene. But Unity being a 3D environment, it has an easy interface to view the scene from different angles, sides, and perspectives using mouse and keyboard shortcuts. You can observe the Scene Gizmo in the top-right corner of the Scene view. This gizmo is used to rotate the view according to the developer's needs. The following screenshot shows the gizmo of the scene:

Every view of the scene is shown in either perspective or isometric. There is also another view for the scene which we will discuss in the next section.

The control bar is shown at the top of the Scene View and it gives the developer more control to navigate through their scenes and create games easily. This bar includes options such as enabling/disabling gizmos, sounds, and selecting view modes. The important part of this bar is the 2D mode button, as shown in the following screenshot:

The 2D mode button is a toggle button; when turned on; it disables the z-axis of the view and show the game from 2D perspective. It is highly used option while creating 2D games in Unity. On the right side of the bar, there is a text box for search. This lets developers search the game objects from the current scene and allows them to quickly work.

The Game View is the final representation of how your game will look when published and deployed on the target devices, and it is rendered from the cameras of the scene. This view is connected to the Play Mode navigation bar at the top of the whole Unity workspace, as shown in the following screenshot:

When the game is played in the editor, this control bar gets changed into blue. A very interesting feature of Unity is that it allows developers to pause the game and code while running and developers can see and change the properties, transforms etc at runtime without recompiling whole game for quick workflow.

Like scene view, game view also includes a control bar on top side of the view as shown in the following figure:

The options perform the actions as their names suggest. The Free Aspect drop-down on the left side of the bar lets developers choose any specific resolution to test their games. These resolutions and drop down options vary on the selected platform. Developers can also add their own custom resolutions and screen sizes for their targeted devices. Unity also allows developers to specify aspect ratios as well to have an idea of how the game will run on various devices with the same aspect ratio. Unity is quite powerful and easily gives cross-platform support to make their games run better on most types of devices writing code only once.

The Hierarchy View is the first point to select or handle any GameObject in the scene. This contains every game object in the current scene. This is tree-type structure allowing developers to utilize parent and child concepts on the game objects easily. The following screenshot shows a simple Hierarchy View:

This looks like a view, but it is called the Project browser panel. This panel is an embedded files directory in Unity and contains all the files and folders included in the game project. 

Following screenshot shows a simple Project browser panel:

The left side of the panel shows a hierarchical directory, while rest of the panel is the files or as these are called assets in Unity. Unity represents these files with different icons to differentiate these according to their file types. These files can be sprite images, textures, model files, sounds and so on. You can search any specific file by typing in the search text box. On the right side of search box, there are button controls for further filters such as animation files, audio clip files, and so on.

This is a most important panel for development in Unity. Unity structures the game in the form of game objects and assets. These game objects further contain components such as transforms, colliders, scripts, and meshes, and so on. Unity lets developers manage these components of each game object through the inspector panel.

The following screenshot shows a simple inspector panel of a game object:

These components vary in type including physics, mesh, effects, audio, and user interface. These components can be added to any object by selecting it from the component menu. The following screenshot shows the Component menu:

After covering some of the basics of the Unity, let's move on to the very first task developers do when creating a game; and that is creating an empty project. Let's discuss the configuration of empty projects in Unity for 2D games in the next section.

When you start a new game, the first step is to configure an empty game project. For 2D games, creating empty games and setting up the initial environment and camera management can sometimes become a painful process. In this section, we will discuss on how to configure empty game projects for 2D games.

When you launch Unity 5.6, it shows a project wizard as shown in the following figure:

Unity has a nice and smooth user interface in its latest release, Unity 5.6. The project wizard shows a list of all the recent projects, along with their names. The most recent project is highlighted for quick opening. In the top-right side of the wizard, there are controls to create a new project from scratch and open any specific project from any directory. To guide new developers through basic concepts, the Get started tab offers a basic video tutorial.

Let's create new project by clicking on the New project button on top-right, and you will be presented with the following dialog box:

There are two text inputs, Project name and Location. Their names are self-explanatory. You will also notice 3D and 2D in the wizard, as shown in following figure:

This toggle lets you tell Unity whether your project is 2D or 3D. Although this doesn't affect the project in any way while working on it, this affects default project setting for easier workflow. For example, in 3D mode, when you import any image asset into project, Unity will take it as a texture and in 2D mode, Unity will take it as a Sprite type. You can also change the mode later from the project anytime, it is not necessary to select at project creation time. By default, Unity will create project in 3D mode.

Along with 2D/3D mode, you will also notice the Asset packages... button at bottom on the project creation wizard. One of the best features of the Unity is the Assets support. Unity lets developers to create, distribute, and sell reusable plugins and add-ons called Unity Assets through Unity Asset Store available at http://assetstore.unity3d.com. Unity comes with a big collection of free assets to help you get some things done within the minutes. This button lets you choose which assets to import in the new project, shown as following:

You can select any package or multiple packages, and the new project will be created with those that have been already imported in it. For now, you don't need to import any packages. You can also import these later as you need it.

So, for the project creation wizard, we have named our project Perky Penguin and we have selected 2D mode. Click on the Create project button, and you will see the Unity interface with an empty scene and project.

The first step to follow is to make sure that you are in 2D or 3D mode. If you have selected 2D mode, then you will see 2D toggle active on the control bar in the Scene View, as shown in the following screenshot:

Also, you need to check in Editor Settings to make sure that the project is in 2D mode. You can do it by going to Editor Settings by selecting Editor option from Project Settings in the Edit menu as shown in the following figure:

On selecting the Editor option, you will see settings in the Inspector panel. Make sure that Mode in Default Behavior Mode is set to 2D, as shown in the following screenshot:

You can also change it to 3D if you want Unity to interpret images as textures and enable other 3D settings by default. The last thing to make sure that the scene is in 2D mode, you need to check the camera properties. You may have already have noticed a Camera game object placed in the empty scene when creating a new project.

Select the Camera object and you will see its properties in inspector panel as shown in the following screenshot:

You will notice that its Position will be set at (0, 0, -10) and its Projection setting will be as Orthographic.

Orthographic projection is a means of representing 3D objects in 2D. Orthographic views are commonly used in engineering as a means of producing object specifications that communicate dimensions unambiguously. For example, if you are looking at a larger scene with buildings then orthographic rendering gives a clear measure of distance between buildings and their relative sizes.

So, after making sure that the project is in 2D mode, let's save the scene. Unity project comes with a root directory of Assets, where all the assets used in project are placed. These assets can be scenes, scripts, textures, sprites, models, prefabs, or materials. There is no traditional or standard method of managing assets in Unity, and every developer has different methods. In this book, we will follow a simple method of managing assets. Our method of managing assets is to create different folders in the Assets directory for each type of resources. The following figure shows the directory structure in the Assets folder:

After creating folders in Assets, let's save the empty scene with the configured camera in the Scenes directory with the name PerkyPenguin_GameplayScene.unity. Scene files have the .unity extension, and these files contain different game objects for camera, player, enemies, obstacles, environment, controls, and so on. Scenes are like different levels in the game. Any game can have one or more than one scenes and it is not necessary to create different scenes for each level. It is very important to note that all the scenes in the game should be added in Build settings in order to deploy them in the final package. We will discuss about deployment in more detail in the later chapters.

After saving the scene, we have only one thing left to fully configure an empty game project. That is configuring the game view so we can test our game. As this book is about Android game development, we have to set our project targeted to Android devices. Initially, the default target platform will be set to PC, iMac, and Linux standalone. You can see it in the Build Settings from the File menu as shown in the following screenshot:

You will be presented with a dialog containing all the possible platforms to build game to and all the scenes included in the game, as shown in the following screenshot:

Select Android from the Platform list, and click on Switch Platform button and the project will be changed for Android devices. You might not notice anything after changing the target platform to Android but an easy way to check it is to see the resolutions list in the game view. You can do it by clicking on Free Aspect from the control bar in Game View as shown in the following figure:

In order to create a game, that runs on all Android devices, we have to select a primary target size for viewport implementation. We have chosen 1280x800 as our target device in landscape mode. We will discuss the cross-resolution approach in details in the later chapters.

You can also add your own custom resolutions by selecting the small plus button in resolution list. It will show you a dialog to put the size of resolution either in pixels or as an aspect ratio with its name. The window is shown in the following figure:

Finally, after setting the project in 2D mode and changing the platform to Android with our required resolution, we have only one little job remaining that is to configure camera according to our target resolution. Select the Main Camera from Hierarchy panel, and change the Size in Camera component to 3.2 as shown in the following figure:

So far, a 2D Unity game project has been created with an initial directory structure and an empty scene which include a 2D configured camera in it. In the next section, we will discuss on what game will be created in this chapter and how to create any game from scratch.

This section is all about the game which we will create throughout this chapter and Chapter 2, Finishing the Perky Penguin 2D Game. Our game name is Perky Penguin and it is a Jetpack Joyride-based game. Final game of this chapter is shown as following:

Perky Penguin is inspired from Jetpack Joyride game. Jetpack Joyride is a 2011 side-scrolling endless runner and action video game created by Halfbrick Studios. It was originally released in 2011 for iOS devices on App Store but it has been ported to many systems including Facebook, Android, Flash, PlayStation, Blackberry, and Windows Phone.

The reason to create a Jetpack Joyride type game for this book is to teach the developers the perspective and methods of how 2D games are created in Unity from scratch. As Jetpack Joyride game includes all the basic functionalities which are implemented almost in all types of 2D games such as side scrolling, parallax scrolling, sprite sheets, jumping, random obstacle generation, enemy generation, enemy Artificial Intelligence, particle systems, and animations.

The game features a penguin that is on ice in very cool (pun intended) and that's why she is called penguin. In order to navigate through an ice field in the time of global warming, she gets a hold of a jetpack, which is tied on her back. The game uses a simple, one-touch system to control the penguin; when the player presses anywhere on the touchscreen, the penguin's jetpack is fired and penguin rises above the ground making a feel like she is flying for a moment. When the player lets go, the jetpack turns off and penguin falls. The game is continuously running in side view, so player is not required to control the speed of penguin. The player is only able to control the vertical movement of penguin by turning the jetpack on and off.

The objective of the game is to travel as far as possible, collect fish coins, and avoid obstacles such as zappers, missiles, and high-intensity laser beams.

In the next section, we will start the development of the Perky Penguin game. We will learn how to add the player, which in our case is a penguin with jetpack tied to her back, to the game.

In this section, we will learn how to add our penguin player to the game and how we can make her alive by writing scripts, applying physics, and adding colliders in it.

Before we do anything, we need a player Sprite or image. For our Perky Penguin game, we have designed a penguin sprite. The following figure shows the penguin that is included as the player sprite of the game:

To import an image in to Unity, right-click on the Graphics folder in the Project Browser panel and click on Import New Asset..., as shown in the following screenshot:

These assets can be anything that is supported by Unity, such as images, audio files, 3D models, textures, materials, and scripts.

Unity shows all the images with nice previews. It must be noted here that if Unity is in 2D mode, then unity will show images as sprites and if mode is set to 3D mode it shows the images as textures. Figure 1.36 shows both scenarios. The following screenshot shows the image imported as sprite and the screenshot besides it shows image imported as texture:

If the penguin image is imported as texture, then there is nothing to worry about. Select the image from Project Browser panel, and in the inspector change the Texture Type to Sprite and click Apply. It is shown in the following figure:

After the assets are imported, which in our case is a single penguin image, we have to create a game object of player. Usually game objects are created by right-clicking in Hierarchy and selecting Create Empty as shows in the following figure:

But, in order to create sprites as game objects, simply drag sprites from the Project Browser panel to Hierarchy or Scene View panels and a game object will be created with the name of image file which is penguin_fly.png here. This is shown in the following figure:

Now it's time to configure the penguin_fly game object of Hierarchy to get used in the game. Now select the penguin_fly object and make following changes in the Inspector panel.

1. Change the game object's name to penguin.
2. Set the position values to (0, 0, 0).

3. To add a collider in the penguin, click Add Component in the inspector and select Circle Collider 2D from Physics2D menu as shown in the following figure. More about Colliders can be read here https://docs.unity3d.com/ScriptReference/Collider.html:

4. Set the value of Radius of Circle Collider 2D to 0.6.
5. To make the penguin behave as a physical object, we have to add Rigid Body component. To add it, click Add Component in the Inspector panel and select Rigid Body 2D from Physics2D as shown in the following figure:

6. Set Fixed Angle checkbox state as checked on to avoid penguin to be rotated while falling or jumping due to physics dynamics.

The following figure below shows all the steps performed on the penguin game object:

Starting from position, we have set the position to zero just for testing purposes. We will change it later when we put penguin at its initial position. The Sprite Renderer component is already added in the penguin game object because penguin game object was created from sprite by dragging it from Project Browser panel. The Sprite Renderer allows any game object to show an image on the screen from any sprite. In order to make any game object to react to physics collisions and get collided with each other, game object requires collider component in it. We have added Circle Collider 2D on the penguin object. You can choose any type of collider from the list. But it is recommended to choose the collider which is very light and fills the whole colliding area. The following figure shows the penguin with different colliders applied to it:

Using complex colliders like Polygon Collider 2D makes it harder to detect collision for the physics engine to detect collision, which in turn, creates a performance penalty. Finally, in order to apply gravity on the penguin, we have added Rigid Body 2D component. Rigid Body 2D allows any game objects to behave to the gravity, friction, physics kinematics and so on. We have check Fixed Angle to on state of the Rigid Body 2D. If this is set to off, then penguin will also rotate due to wind, friction, gravity, or any other force applied on it. So in order to avoid her to rotate while jumping, we have set Fixed Angle as checked.

When you run the project, you will notice that penguin will fall down on the screen. It is because of the gravity is pulling penguin downwards and it goes off the screen. The Gravity Scale value, which is 1 by default, decides the gravity of the penguin. If we remove or disable Rigid Body 2D component, then penguin will never move. So, it must be noted that without rigid body no force and collision will be applied on the game object.

After setting physics components and position on penguin object, it's time to define some logic behavior of the penguin. The game's requirements are to let penguin fly through its jetpack when screen is touched by player and penguin will fall when touch is stopped. These kinds of logic are defined in Unity through scripts. Unity supports 2 kinds of scripts; C# and JavaScript. You can use any of these scripts. Even you can also use few files in C# and few other files in JavaScript in the same project. Throughout this book, we will do all the scripting through C#.

1. We will start by creating a C# script file in Scripts folder in Assets by right-clicking on Scripts folder and choose C# Script from Create menu as shown in the following figure:

2. Let's call this script as PenguinController.cs and when you open it, the Unity's default Code Editor Visual Studio will start and open the newly created script file it as shown in the following figure.

3. You might notice some code already written in this file. We will discuss about it in a while. Now a script has been created, but this script is not linked or connected to our penguin object or even the game. In order to apply it on the penguin object, select penguin game object, click on Add Component in the Inspector panel, and choose PenguinController.cs from Scripts menu as shown in the following figure:

Now, as the script is applied on the penguin game object, let's write some logic and code to make the penguin fly. Open PenguinController.cs file from project browser panel by double-clicking it in MonoDevelop. The code which is already written looks like the following screenshot:

4. The PenguinController class is inherited from MonoBehaviour class. Any script to be applied on any game object placed in the scene should be a MonoBehaviour class and this is done by inheriting the class from it. MonoBehaviour class provides some basic functionality for game objects such as its life cycle like when object is created, when it is active, when it is destroyed etc. Also it provides some functionality like interactions such as mouse down or mouse up etc. For now, we have only two methods Start() and Update(). The Start() method is called when the game object becomes first time active on the scene at runtime and Update() method is called on each frame if the game object is enabled or active.

5. Now, let's start our logic for penguin. We will start from creating a variable jetpackForce in the class like this:

        public float jetpackForce = 75.0f;

6. We have set its initial float value to 75 and f letter is to make it float literal. There is an interesting thing about Unity that all the public fields in any class will be shown in game object's inspector component and can be altered or modified directly from the editor without opening the code file. The following shows the jetpackForce variable's field in the inspector panel:

7. Next is to use this jetpackForce's value as the force to apply on penguin when touch is pressed. In order to detect touches, we have to use Input.GetButton() method. But this method is better used in either Update() or FixedUpdate() methods of MonoBehaviour class. The FixedUpdate() method is called every fixed frame instead of every frame. Meaning that in FixedUpdate() if the FPS of the game is 60 then the FixedUpdate function will be called 60 times in a second. Irrespective if there are any changes to the scene. In comparison the Regular Update () function gets doesn't stick to the 60 fps rule and will update when there is a change in the scene. This should be used when dealing with RigidBody. As our penguin is a RigidBody2D, so it's better to use FixedUpdate() method than Update(). The PenguinController.cs script doesn't contain FixedUpdate() method, so let's add the following code in the class now:

        void FixedUpdate()
        {
            bool jetpackkActive = Input.GetButton ("Fire1);
            if (jetpackActive = true) {
                this.GetComponent<Rigidbody>().AddForce(new Vector2(0, 
                jetpackForce));
            }
        }

8. There is nothing difficult here. We are polling for the input of Fire1 button which is a left-click in case of any PC, Linux, or MAC build and it changes to touch on Android, iPhone or other touch device. If the screen is touched, then GetButton() will return true value, which in turn lets script add force by calling AddForce() method of the RigidBody2D component and passing the jetpackForce value in the y-direction.

Following is the whole PenguinController.cs file's code: 

9. Now, when you run the game the penguin will start falling. On clicking on screen, the penguin will rise up a little and will start falling again. The more frequently clicks are performed, the higher penguin will go up and it will easily be out of the screen within 2 or 3 clicks. Also it is falling very fast. In order to adjust its speed, either we decrease Gravity Scale from RigidBody2D of the penguin object as shown in the following figure on left side or we decrease the Gravity in the Physics2D settings shown in the figure on right side.

We will change the Gravity value of Physics2D settings to -15. You can open Physics2D settings from Edit - Project Settings - Physics2D menu.

Now run the game, and you will notice the penguin will fall slower than before. On clicking many times, you might notice that penguin gets out of the screen. This kind of behavior in the games should be avoided. So, in order to limit the penguin within the screen bounds, we will add floor and ceiling in the game. Let's see how it's done in the next section.

Adding floor and ceiling is quite simpler job. We will create an empty object first. It should be noted that we are not importing any images or sprite assets in the scene, because we only need boundaries not the visuals of those about how these will look. Here is how we create our floor object.

• Create empty game object by choosing GameObject - Create Empty menu.
• Select newly created empty game object in the Hierarchy panel.
• Rename it to floor.
• Set its Position to (0, -3.25, 0).
• Set its Scale to (14.4, 1, 1).
• Add Box Collider 2D component by clicking on Add Component, and selecting Physics2D - Box Collider 2D option.

Now you should be seeing a green rectangle on bottom of screen. This is the box collider of the floor and when you run the game, the penguin will never fall off the screen and it will stop when collided with the floor.

Similarly, now add ceiling game object with the name ceiling and its position of (0, 3.25, 0) and its scale of (14.4, 1, 1). Apply Rigid Body 2D component on the ceiling object, and now run the project. You will observe that penguin now never leaves the screen and it is limited between the upper and lower parts of the screen.

In this chapter, we learnt about what is Android and about its different versions. We also learnt about different game engines such as Unity3D, Unreal Engine, Game Maker Studio, or Adobe Flash used to create games for Android devices. We also learnt about important features of Unity along with its basics of its development environment. After learning basics of unity game development, we learnt about configuration of any empty game projects for 2D games. Then we got introduced to the Perky Penguin game which started getting developed in this chapter. A penguin was added and its basic flying and falling functionality was created in this chapter then.

In the next chapter, we will finish the Perky Penguin game and see how particle systems, animations, enemies, and so on, are all developed in Unity.