{"id":82980,"date":"2019-01-16T20:08:25","date_gmt":"2019-01-16T20:08:25","guid":{"rendered":"https:\/\/www.red-gate.com\/simple-talk\/?p=82980"},"modified":"2021-07-29T19:44:09","modified_gmt":"2021-07-29T19:44:09","slug":"introduction-to-mobile-development-with-unity","status":"publish","type":"post","link":"https:\/\/www.red-gate.com\/simple-talk\/development\/dotnet-development\/introduction-to-mobile-development-with-unity\/","title":{"rendered":"Introduction to Mobile Development with Unity"},"content":{"rendered":"

Two things were introduced in 2008 almost at the same time. The iOS and Google Play Store opened up the world of mobile gaming. This new world introduced a new way to play games, all on your smartphone. Since then, it has only gotten easier to create your own apps and release them on a store for all to download and play instantly. It should come as no surprise then that Unity can be used to easily create your own mobile projects. Whether you intend to make a game for yourself or for the world, for iOS or Android, you can make that vision come to life with Unity.<\/p>\n

But where do you get started? The same place any creator should begin\u2014with the basics. Follow along and you’ll create a basic app using Unity that does three simple tasks. The first objective is to tap on an object to make it change color. Next, a button will be created that the user may tap whenever they wish to lock the game camera in place. Why would you lock the camera? Well, for the final objective you will be rotating the in-game camera using your phone’s gyroscope. That’s right, by moving your phone in real life the camera will move in your game. All these tasks combine to create a simple app that introduces you to the basics of creating a mobile game in Unity.<\/p>\n

Setup<\/h2>\n

Creating the project is like any other Unity project. Being a mobile project does not change this part of the process. After opening Unity, create a new project as shown in Figure 1.<\/p>\n

Figure 1: Creating a new project<\/p>\n

Next, name this MobileIntro<\/em>. Make sure the project is a 3D<\/em> project then choose the Location<\/em> for the project. Once you’ve done all this, you’re ready to create the project. It should look similar to Figure 2.<\/p>\n

Figure 2: Naming and creating the project.<\/p>\n

You may wish to start by creating the objects that will be important to this project. Start by creating a cube. This will be the object the user can tap to change its color to a random color. To create this object, click the Create <\/em>button in the Hierarchy <\/em>window. Then navigate to 3D Object->Cube <\/em>to create the cube object as shown in Figure 3.<\/p>\n

<\/p>\n

Figure 3: Creating a cube.<\/p>\n

The cube is rather small at the moment, and anyone that’s done virtually anything with a mobile app knows how difficult it is to tap small objects. You’ll want to increase the cube’s size. Click on the Cube <\/em>object in the Hierarchy<\/em>. After this, navigate to the Inspector <\/em>window and find the Transform <\/em>component. This should be the first component you see at the very top of the Inspector <\/em>window. Once found, change all variables in the Scale <\/em>fields to four as shown in Figure 4.<\/p>\n

<\/p>\n

Figure 4: Naming the object and setting the scale.<\/p>\n

Next, you’ll create two more objects. The first is simply a manager that will hold the script that makes the project run. The second will be the user interface (UI) that the user can interact with to lock the game’s camera to its current position. Using the same Create <\/em>menu in the Hierarchy <\/em>window, create an empty game object and call it GameManager<\/em>. Then, once again using the Create <\/em>menu, navigate to UI->Button <\/em>to create the button that the user will tap to perform the camera locking function. When finished, the Hierarchy <\/em>should look similar to Figure 5 below.<\/p>\n

<\/p>\n

Figure 5: The current hierarchy.<\/p>\n

You may need to adjust the position of the button you just created to get it in exactly the position you want. Select the Button <\/em>object in the Hierarchy <\/em>window and go to the Transform <\/em>component in the Inspector<\/em>. Set the anchor to the top left part of the screen. Then set Pos X <\/em>to 50 and Pos Y <\/em>to -40. Finally, change the Width<\/em> and Height<\/em> of the button to 100 as shown in Figure 6.<\/p>\n

<\/p>\n

Figure 6: Setting the anchor, position, width, and height.<\/p>\n

Next, you will want to change the text of the button to say LOCK. <\/em>In the Hierarchy<\/em> window, click the arrow next to the Button <\/em>object as shown in Figure 7.<\/p>\n

<\/p>\n

Figure 7: Opening the child objects.<\/p>\n

The button’s Text <\/em>object will appear. Select it and navigate to the Text <\/em>component in the Inspector <\/em>window. You’ll then need to change the text to say LOCK<\/em>, then adjust the size of the text using Font Size<\/em>. When finished, the component should look like Figure 8 below.<\/p>\n

<\/p>\n

Figure 8: Setting the text and font size.<\/p>\n

With this completed, all the objects needed for the project are in place, but it’s not quite time to write code yet. As this is intended to be a mobile project, you will need to perform a few actions to make the program run on your mobile device. From the top menu select File->Build Settings<\/em> as shown in Figure 9.<\/p>\n

<\/p>\n

Figure 9: Opening the build settings.<\/strong><\/p>\n

This opens up the Build Settings dialog which shows you the many platforms where you could run an app created in Unity. For each platform, however, different modules will need to be installed. Figure 10 shows the dialog and the message you\u2019ll see about installing the module for Android development.<\/p>\n

<\/p>\n

Figure 10: The Build Settings <\/em>without having the necessary modules installed.<\/strong><\/p>\n

This is where you would go to build your project to be run on whichever device you choose. In addition, you can navigate to the player settings and change some properties of your build such as the image your application will use. Depending on how you installed Unity you may also need to install the Android or iOS modules for your copy of Unity. You can use the same Unity installer you used to install Unity onto your machine to do this. Just be sure to only select the Android and\/or the iOS module for installation.<\/p>\n

You may also need to download an SDK for your project to work. This example will be looking at how to install the Android SDK in particular. This can be accomplished either through command line tools or the Android Studio application. Instructions for both methods can be found in Unity’s documentation, found here<\/a>.<\/p>\n

If you already have the above completed, then you’ll need to let Unity know that this is a mobile project. Once again, the example figures will show selecting Android devices as the platform of choice, but you should just as easily be able to use this project on an iOS device. Select the appropriate mobile device for you, then near the bottom of the Build Settings <\/em>window you will need to click Switch Platform<\/em> as shown in Figure 11.<\/p>\n

<\/p>\n

Figure 11: Switching platforms.<\/p>\n

Once this is done, Unity will rebuild the project and set the target platform to your choice. You’ll see the Unity logo will be next to the platform you selected once the process is complete. Now you’ll need to change a few of the player settings for your project. To the immediate right of the Switch Platform <\/em>button (now grayed out), click Player Settings<\/em> shown in Figure 12.<\/p>\n

<\/p>\n

Figure 12: Platform selected. Now on to player settings.<\/p>\n

The Inspector window <\/em>will change showing which player settings you can change for your project. You can do a lot here such as change the app icon or API settings. For this project you will start by changing the orientation of the app. Click Resolution and Presentation, <\/em>then find the Orientation <\/em>settings. This project will assume you set the orientation to Landscape Right<\/em>. Figure 13 shows the settings.<\/p>\n

<\/p>\n

Figure 13: Setting your app’s default orientation.<\/p>\n

After this, search for Other Settings<\/em>. In order to test your project on your phone later, you will need to set up a package name for the project. Under Other Settings <\/em>you will need to locate the Package Name <\/em>field. The required format for this package name is com.CompanyName.PackageName<\/em>. Leave the com <\/em>part of the name and change the CompanyName <\/em>and PackageName<\/em>. It can be set to whatever you wish, but the example below in Figure 14 will simply use com.mycompany.mobileintro<\/em> as the package name for the project.<\/p>\n

<\/p>\n

Figure 14: Creating a package name for apk file.<\/p>\n

Your project’s mobile specific settings have now been configured, and it is time to write the project’s code. Right click in the Assets <\/em>window and select Create->C# Script<\/em> as shown in Figure 15.<\/p>\n

<\/p>\n

Figure 15: Creating a C# script.<\/p>\n

Name this script PlayScript<\/em>. Once you’re done, the Assets <\/em>window should look similar to Figure 16.<\/p>\n

<\/p>\n

Figure 16: The Assets <\/em>window with PlayScript<\/em><\/p>\n

Double click the script to open it up in Visual Studio.<\/p>\n

The Code<\/h2>\n

Thankfully, no additional using statements are needed to make this project. The line using UnityEngine<\/code> should already be in the code upon creation. In addition, you’ll need to add using UnityEngine.UI<\/code> in order to change the text of the UI button. Finally, you’ll need to declare some variables that will relate to three objects in the project. These objects are the in-game camera, the text in the button, and the cube you created.<\/p>\n

public GameObject mainCamera;\r\npublic MeshRenderer cubeRender;\r\npublic Text buttonText;<\/pre>\n
After this, a few private variables will be declared. One of them is of the type Gyroscope<\/code>. As you may have guessed, this has to do with your phone’s internal gyroscope that will be used to move the in-game camera. The next variable, called rotMultiplier<\/code>, is used to increase how much the camera moves when you rotate your phone. By default, it’s not going to move very far. With this variable you can increase the amount the camera moves whenever the gyroscope detects rotation. In this example the value of rotMultiplier<\/code> is fifty, but you may need to adjust this number in your own project. Finally, a boolean<\/code> is created that will tell the project whether to lock the camera or not.<\/p>\n
private Gyroscope gyro;\r\nprivate float rotMultiplier = 50;\r\nprivate bool lockCam = false;<\/pre>\n
Now, you move on to the Start<\/code> function. Whenever the game starts, there will be a quick check to see if the phone you’re using has a gyroscope. Most mobile devices these days have gyroscopes, so why even have the check? This is primarily done to enable the gyroscope functionality for Unity. If for some reason, a mobile device lacks a gyroscope, this could prevent the project from crashing. In that event, you would most likely desire to add an else<\/code> statement after the if<\/code> statement and perform anything you wish the project to do in the event that the gyroscope is unavailable. However, this example will assume that your device has a gyroscope, and that no further code is needed. In the interest of good coding habits, the if statement will be used in this example.<\/p>\n
if (SystemInfo.supportsGyroscope)\r\n{\r\n\tgyro = Input.gyro;\r\n\tgyro.enabled = true;\r\n}<\/pre>\n
The Start<\/code> function is complete and the code should look similar to Figure 17.<\/p>\n
<\/p>\n
Figure 17: Variable declarations and Start <\/em>function.<\/p>\n
Next, you’ll need to move on to the Update<\/code> function. Here you will code in the functionality to detect when the cube has been tapped on as well as the camera rotation. The code that catches when the cube has been tapped is as follows:<\/p>\n
if (Input.GetMouseButtonDown(0))\r\n{\r\n\tRay ray = mainCamera.GetComponent<Camera>().ScreenPointToRay(\r\n                 new Vector3(Input.GetTouch(0).position.x, \r\n                 Input.GetTouch(0).position.y, 0));\r\n\tRaycastHit raycastHit;\r\n\tif (Physics.Raycast(ray, out raycastHit))\r\n\t{\r\n\t\tfloat r, g, b;\r\n\t\tr = Random.Range(0.0f, 1.0f);\r\n\t\tg = Random.Range(0.0f, 1.0f);\r\n\t\tb = Random.Range(0.0f, 1.0f);\r\n\t\tcubeRender.material.color = new Color(r, g, b);\r\n\t}\r\n}<\/pre>\n
That’s curious. Why are you looking for mouse input? Here’s a handy little tip about Unity. You can use some of the same code that you would use for both games that run on a desktop computer as well as games that run on mobile devices. While you could specifically search for a tap of the screen, you may find it easier to simply look for a mouse click. Plus, if you aim to make a project that can work on both PC and mobile, that’s less code to change for each version. This can also be helpful when testing the program on a desktop computer before performing further testing on mobile.<\/p>\n
You check to see if a mouse click<\/em> has occurred. Once you do that, a raycast<\/code> is created at the point where the mouse cursor<\/em> was located at the time. A raycast<\/code> can be thought of as an arrow being shot forward. If it hits something, the program can then gain information on what was hit and even change the object in question upon impact. A good example of this lies in nearly every first-person shooter game. Whenever you fire a gun, you’re not really shooting a bullet out of a gun. Rather, the game is firing a raycast<\/code> from the gun. Depending on what it hits, a certain action will occur whether that be damaging an enemy or leaving a hole in the wall.<\/p>\n
In this case, whenever a raycast<\/code> hits your cube, the cube will get a new random color applied to it. After getting three random numbers representing red, green, and blue, you get the color <\/em>variable from cubeRender<\/code> and assign the new color. After these, you create the code that controls the camera movement. These next two lines of code are fairly simple. If the lockCam<\/code> variable is false, then rotate the camera based on the inputs from the gyroscope.<\/p>\n
if (lockCam == false)\r\n   mainCamera.transform.rotation = \r\n       Quaternion.Euler(\r\n            gyro.attitude.x * rotMultiplier, \r\n            gyro.attitude.y * rotMultiplier, 0);<\/pre>\n
With this code entered into the Update<\/code> function, you can now move on. The code should look like Figure 18.<\/p>\n
<\/p>\n
Figure 18: The Update <\/em>function.<\/p>\n
Before exiting Visual Studio, there’s one last function to be created. This function, called LockCamera<\/code>, will be put to use in the UI button you made earlier. Whenever you tap that button, this function will be called. All it does is set lockCam<\/code> to true or false and changes the text in your button. Placed underneath the Update<\/code> function, the code looks like this:<\/p>\n
public void LockButton()\r\n{\r\n\tif (lockCam == false)\r\n\t{\r\n\t\tlockCam = true;\r\n\t\tbuttonText.text = \"UNLOCK\";\r\n\t}\r\n\telse\r\n\t{\r\n\t\tlockCam = false;\r\n\t\tbuttonText.text = \"LOCK\";\r\n\t} \r\n}<\/pre>\n
And with that out of the way, the code for this project is complete. Save your work and head back to the Unity editor to finish the project.<\/p>\n
Completing the Project<\/h2>\n
Remember the GameManager <\/em>object from before? You’ll attach your freshly made script to this object. With GameManager <\/em>selected in the Hierarchy<\/em>, click and drag PlayScript <\/em>from the assets window into the Inspector<\/em> as shown in Figure 19.<\/p>\n
<\/p>\n
Figure 19: Attaching PlayScript <\/em>to the GameManager<\/em><\/p>\n
Next, you’ll need to fill in the Main Camera <\/em>and Cube Render <\/em>fields. In the Hierarchy<\/em>, select the Main Camera <\/em>object and drag it into the Main Camera <\/em>field. Likewise, drag Cube <\/em>into Cube Render. <\/em>Figure 20 shows how this looks.<\/p>\n
<\/p>\n
Figure 20: Setting the Main Camera, Button Text, <\/em>and Cube Render <\/em>variables.<\/p>\n
Next, locate the Button <\/em>object in the Hierarchy<\/em>. After selecting it, find the On Click <\/em>event list in the Inspector<\/em> as shown in Figure 21.<\/p>\n
<\/p>\n
Figure 21: List of On Click <\/em>events, currently empty.<\/p>\n
Click the + <\/em>icon to add a new On Click <\/em>event to your button shown in Figure 22.<\/p>\n
<\/p>\n
Figure 22: Adding an On Click <\/em>event.<\/p>\n
After this you will need to click and drag GameManager <\/em>from the Hierarchy <\/em>into the Object <\/em>field. Figure 23 shows you what to do.<\/p>\n
<\/p>\n
Figure 23: Setting GameManager <\/em>as the object to pull code from.<\/p>\n
Once this is complete, click the drop down menu that current says No Function<\/em>. Navigate to PlayScript->LockButton <\/em>to set the LockButton <\/em>function to this button’s On Click <\/em>event as shown in Figure 24.<\/p>\n
<\/p>\n
Figure 24: Setting LockButton <\/em>as the function to call when your button is tapped.<\/p>\n
Two steps remain before you can test your project out properly. The necessary modules and SDK you need for the project have been installed. Unfortunately, the SDK doesn’t do much good if Unity doesn’t know where it is. Go to Edit->Preferences <\/em>to take care of that as shown in Figure 25.<\/p>\n
<\/p>\n
Figure 25: Accessing Unity Preferences.<\/p>\n
This opens the Unity Preferences<\/em> dialog where you adjust settings such as the colors Unity uses. For this project, you’ll want to navigate to External Tools<\/em> shown in Figure 26.<\/p>\n
<\/p>\n
Figure 26: Navigating to External Tools<\/em>.<\/p>\n
Scroll down until you find settings for Android. This is where you specify the file path for your SDK as well as the JDK (Java Development Kit) and Android NDK. You can also download the things you need using the convenient Download <\/em>button. For mobile projects, you’ll at least want the SDK and JDK filled in. After installing everything you need, use the Browse <\/em>button and find the path to your SDK and JDK as shown in Figure 27.<\/p>\n
<\/p>\n
Figure 27: Specifying a path for the Android SDK and JDK.<\/p>\n
There’s another step involved to make this project run on your phone, but it takes place outside of Unity. You’ll need to enable developer mode on your mobile device in order to build the project to your phone. On Android, you simply need to navigate to Settings->About phone<\/em>->Software Information and then find the Build Number<\/em>. Tap Build Number <\/em>multiple times to enable developer mode on your phone. For iOS, the process is a little different. You’ll need Xcode<\/em> running on your desktop, followed by plugging a USB cable from your phone into the computer. From there, navigate your settings until you find Developer<\/em>. Finding this means you have developer mode enabled on your phone.<\/p>\n
After all the above steps have been completed, your project is now ready, but how do you test this out on your phone? After all, it’s hard to test gyroscope functionality on a desktop computer. You can get around this by navigating to File->Build Settings<\/em>. Once there, you’ll need to click the Build and Run <\/em>button near the bottom of the window shown in Figure 28.<\/p>\n
<\/p>\n
Figure 28: Building your project and running it on your mobile device.<\/p>\n
This will build your game and then upload it to your phone. From there the program should begin running on your phone. Of course, you will need a USB cable connected from your computer to your mobile device for this method to work. Another window will pop up before the build begins saying you need to save the apk<\/em> file somewhere on your computer. You may save this file wherever you wish, as it will not affect building the apk<\/em> to your phone. In addition, it’s possible that a dialogue box with a message about JDK will pop up saying it found an up to date version. Go ahead and click Yes <\/em>on this dialogue.<\/p>\n
Once the build is complete, you should see your project begin to play on your phone. If for some reason it doesn’t play automatically, try searching around your apps and see if MobileIntro <\/em>is anywhere to be found. Once the game begins, go ahead and rotate the device and notice the in-game camera move with your phone’s movements. If there’s a certain angle you like, you can tap the UI button near the top right to lock the camera in place. Finally, try tapping the cube and watch it change to a random color. Remember when I said that you can look for mouse input when looking for taps on your phone screen? You can see that in action both by tapping the cube and tapping the UI button. The app will look something like Figure 29.<\/p>\n
<\/p>\n
Figure 29: Mobile project in action.<\/p>\n
Conclusion<\/h2>\n
As you can see, creating a mobile project is easier than you might think. If you ever wanted to create another mobile game in the future, some settings you edited here in Unity would carry over into other projects, namely the path to the SDK. In some cases, there isn’t much difference between code for a mobile project and code for a PC project, so controlling different versions of the same app becomes easier too. However, it would have been a little underwhelming if all you did was make code that works on both PC and mobile, so you took advantage of your mobile device’s gyroscope to move the camera in time with your own movements. From here you can build off this example project to create your own mobile experience, whatever that may be.<\/p>\n
 <\/p>\n","protected":false},"excerpt":{"rendered":"
In today\u2019s world, some people do not need computers because they can do everything on their smartphones. Playing games is no different and is one of the most popular uses for the mobile devices (who makes phone calls, anymore?). In this article, Lance Talbert shows you how to create a game that will run on an Android device.…<\/p>\n","protected":false},"author":317499,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[143538,53],"tags":[95509],"coauthors":[52549],"class_list":["post-82980","post","type-post","status-publish","format-standard","hentry","category-dotnet-development","category-featured","tag-standardize"],"acf":[],"_links":{"self":[{"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/posts\/82980","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/users\/317499"}],"replies":[{"embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/comments?post=82980"}],"version-history":[{"count":5,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/posts\/82980\/revisions"}],"predecessor-version":[{"id":83011,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/posts\/82980\/revisions\/83011"}],"wp:attachment":[{"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/media?parent=82980"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/categories?post=82980"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/tags?post=82980"},{"taxonomy":"author","embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/coauthors?post=82980"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}