Welcome to the wonderful world of mobile game development. Whether you are still looking for the right development kit or have already chosen one, this chapter will be most important. In this chapter we explore the various features that come with choosing Unity as your development environment and Android as the target platform. Through comparison with major competitors, it is discovered why Unity and Android stand on the top of the pile. Following that, we examine how Unity and Android work together. Finally, the development environment is set up and we create a simple Hello World application to test that everything is set up correctly. For the purposes of this book, it is assumed you are working in a Windows-based environment.
In this chapter, we will cover the following topics:
Major Unity features
Major Android features
Unity licensing options
Installing the JDK
Installing the Android SDK
Installing Unity 3D
Installing Unity Remote
Perhaps the greatest feature of Unity is how open-ended it is. Nearly all game engines currently on the market are limited in what one can build. It makes perfect sense but it can limit the capabilities of a team. The average game engine has been highly optimized for creating a specific game type. This is great if all you plan on making is the same game again and again. When one is struck with inspiration for the next great hit, only to find that the game engine can't handle it and everyone has to retrain in a new engine or double the development time to make it capable, it can be quite frustrating. Unity does not suffer this problem. The developers of Unity have worked very hard to optimize every aspect of the engine, without limiting what types of games can be made. Everything ranging from simple 2D platformers to massive online role-playing games is possible in Unity. A development team that just finished an ultra-realistic first-person shooter can turn right around and make 2D fighting games without having to learn an entirely new system.
Being so open ended does, however, bring a drawback. There are no default tools optimized for building that perfect game. To combat this, Unity grants the ability to create any tool one can imagine, using the same scripting that creates the game. On top of that, there is a strong community of users that have supplied a wide selection of tools and pieces, both free and paid, to be quickly plugged in and used. This results in a large selection of available content, ready to jump-start you on your way to the next great game.
When many prospective users look at Unity, they think that because it is so cheap, it is not as good as an expensive AAA game engine. This is simply not true. Throwing more money at the game engine is not going to make a game any better. Unity supports all of the fancy shaders, normal maps, and particle effects you could want. The best part is, nearly all of the fancy features you could want are included in the free version of Unity and 90 percent of the time beyond that, one does not need to even use the Pro only features.
One of the greatest concerns when selecting a game engine, especially for the mobile market, is how much girth it will add to the final build size. Most are quite hefty. With Unity's code stripping, it becomes quite small. Code stripping is the process by which Unity removes every extra little bit of code from the compiled libraries. A blank project, compiled for Android, that utilizes full code stripping ends up being around 7 megabytes.
Perhaps one of the coolest features of Unity is the multi-platform compatibility. With a single project one can build for several different platforms. This includes the ability to simultaneously target mobile, PC, and consoles. This allows one to focus on real issues, such as handling inputs, resolution, and performance.
In the past, if a company desired to deploy their product on more than one platform, they had to nearly double the development costs in order to essentially reprogram the game. Every platform did, and still does, run by its own logic and language. Thanks to Unity, game development has never been simpler. We can develop games using simple and fast scripting, letting Unity handle the complex translation to each platform.
There are of course several other options for game engines. Two major ones that come to mind are cocos2d and Unreal Engine. While both are excellent choices, we can always find them to be a little lacking in certain respects.
The engine of Angry Birds, cocos2d, could be a great choice for your next mobile hit. However, as the name suggests, it is pretty much limited to 2D games. A game can look great in it, but if you ever want that third dimension, it can be tricky to add. A second major problem with cocos2d is how bare bones it is. Any tool for building or importing assets needs to be created from scratch, or they need to be found. Unless you have the time and experience, this can seriously slow down development.
Then there is the staple of major game development, Unreal Engine. This game engine has been used successfully by developers for many years, bringing great games to the world; Unreal Tournament and Gears of War not the least among them. These are both, however, console and computer games, which is the fundamental problem with the engine. Unreal is a very large and powerful engine. Only so much optimization can be done for mobile platforms. It has always had the same problem; it adds a lot of girth to a project and its final build. The other major issue with Unreal is its rigidity in being a first-person shooter engine. While it is technically possible to create other types of games in it, such tasks are long and complex. A strong working knowledge of the underlying system is a must before achieving such a feat.
All in all, Unity definitely stands strong among the rest. Perhaps you have already discovered this, and that is why you are reading this book. But these are still great reasons for choosing Unity for game development. Projects can look just as great as AAA titles. Overhead and girth in the final build is small and very important when working on mobile platforms. The system's potential is open enough to allow you to create any type of game you might want, where other engines tend to be limited to a single type of game. And should your needs change at any point in the project's life cycle, it is very easy to add, remove, or change your choice of target platforms.
With over 30-million devices in the hands of users, why would you not choose the Android platform for your next mobile hit? Apple may have been the first one out of the gate with their iPhone sensation, but Android is definitely a step ahead when it comes to smartphone technology. One of its best features is its blatant ability to be opened up so you can take a look at how the phone works, both physically and technically. One can swap out the battery and upgrade the micro SD card, should the need arise. Plugging the phone into a computer does not have to be a huge ordeal; it can simply function as removable storage media.
From the point of view of cost of development, the Android market is superior as well. Other mobile app stores require an annual registration fee of about 100 dollars. Some also have a limit on the number of devices that can be registered for development at one time. The Google Play market has a one-time registration fee, and there is no concern about how many or what type of Android devices you are using for development.
One of the drawbacks about some of the other mobile development kits is that you have to pay an annual registration fee before you have access to the SDK. With some, registration and payment are required before you can view their documentation. Android is much more open and accessible. Anybody can download the Android SDK for free. The documentation and forums are completely viewable without having to pay any fee. This means development for Android can start earlier, with device testing being a part of it from the very beginning.
Because Unity handles projects and assets in a generic way, there is no need to create multiple projects for multiple target platforms. This means that you could easily start development with the free version of Unity and target personal computers. Then, at a later date, you can switch targets to the Android platform with the click of a button. Perhaps, shortly after your game is launched, it takes the market by storm and there is a great call to bring it to other mobile platforms. With just another click of the button, you can easily target iOS without changing anything in your project.
Most systems require a long and complex set of steps to get your project running on a device. For the first application in this book, we will be going through that process because it is important to know about it. However, once your device is set up and recognized by the Android SDK, a single-button click will allow Unity to build your application, push it to a device, and start running it. There is nothing that has caused more headaches for some developers than trying to get an application on a device. Unity makes it simple.
With the addition of a free Android application, Unity Remote, it is simple and easy to test mobile inputs without going through the whole build process. While developing, there is nothing more annoying than waiting for 5 minutes for a build every time you need to test a minor tweak, especially in the controls and interface. After the first dozen little tweaks the build time starts to add up. Unity Remote makes it simple and easy to test it all without ever having to hit the Build button.
These are the big three: generic projects, a one-click build process, and Unity Remote. We could, of course, come up with several more great ways in which Unity and Android can work together. But these three are the major time and money savers. You could have the greatest game in the world but, if it takes 10 times as long to build and test, what is the point?
Unity comes with two licensing options, Pro and Basic, which can be found at https://store.unity3d.com. In order to follow the bulk of this book, Unity Basic is all that is required. However, real-time shadows in Chapter 4, Setting the Stage – Camera Effects and Lighting, the whole of Chapter 5, Getting Around – Pathfinding and AI, and some of the optimization features discussed in Chapter 9, Optimization, will require Unity Pro. If you are not quite ready to spend the $3,000 required to purchase a full Unity Pro license with the Android add-on, there are other options. Unity Basic is free and comes with a 30-day free trial of Unity Pro. This trial is full and complete, just as if one has purchased Unity Pro. It is also possible to upgrade your license at a later date. Where Unity Basic comes with mobile options for free, Unity Pro requires the purchase of Pro add-ons for each of the mobile platforms.
License comparisons can be found at http://unity3d.com/unity/licenses. This section will cover the specific differences between Unity Android Pro and Unity Android Basic. We will explore what the feature is and how useful it is.
NavMeshes, Pathfinding, and crowd Simulation: This feature is Unity's built-in pathfinding system. It allows characters to find their way from point to point around your game. Just bake your navigation data in the editor and let Unity take over at runtime. This feature is great if you don't have the ability or inclination to program a pathfinding system yourself. There is a whole slew of tutorials online about how to program pathfinding and do crowd simulation. It is completely possible to do all of this in Unity Basic; you just need to provide the tools yourself.
LOD Support: LOD (Level-of-detail) lets you control how complex a mesh is, based on its distance from the camera. When the camera is close to an object, render a complex mesh with a bunch of detail in it. When the camera is far from that object, render a simple mesh, because all that detail is not going to be seen anyway. Unity Pro provides a built-in system to manage this. However, this is another system that could be created in Unity Basic. Whether using Pro or not, this is an important feature for game efficiency. By rendering less complex meshes at a distance, everything can be rendered faster, leaving more room for awesome gameplay.
Audio Filter: Audio filters allow you to add effects to audio clips at runtime. Perhaps you created gravel footstep sounds for your character. Your character is running, and we can hear the footsteps just fine, when suddenly they enter a tunnel and a solar flare hits, causing a time warp and slowing everything down. Audio filters would allow us to warp the gravel footstep sounds to sound like they are coming from within a tunnel and are slowed by a time warp. Of course, you could also just have the audio guy create a new set of tunnel gravel footsteps in the time warp sounds. But this might double the amount of audio in your game and limits how dynamic we can be with it at runtime. We either are or are not playing the time warp footsteps. Audio filters would allow us to control how much time warp is affecting our sounds.
Video Playback and Streaming: When dealing with complex or high-definition cut scenes, being able to play a video becomes very important. Including them in a build especially with a mobile target can require a lot of space. This is where the streaming part of this feature comes in. This feature not only lets us play video, it also lets us stream that video from the internet. There is, however, a drawback to this feature. On mobile platforms, the video has to go through the device's built-in, video-playing system. This means the video can only be played full-screen and cannot be used as a texture. Theoretically, though, you could break your video into individual pictures for each frame and flip through them at runtime, but this is not recommended for build size and video quality reasons.
Fully Fledged Streaming with Asset Bundles: Asset bundles are a great feature provided by Unity Pro. They allow you to create extra content and stream it to the users, without ever requiring an update to the game. You could add new characters, levels, or just about any other content you can think of. Their only drawback is that you cannot add more code. The functionality cannot change, but the content can. This is one of the best features of Unity Pro.
100,000 Dollar Turnover: This one isn't so much a feature as it is a guideline. According to Unity's End User License Agreement, the basic version of Unity cannot be licensed by any group or individual that made $100,000 in the previous fiscal year. This basically means, if you make a bunch of money, you have to buy Unity Pro. Of course, if you are making that much money, you can probably afford it without issue. That is the view of Unity at least, and the reason why it is there.
Mecanim: IK Rigs: Unity's new animation system, Mecanim, supports many exciting new features, one of which is IK. If you are unfamiliar with the term, IK allows one to define the target point of an animation and let the system figure out how to get there. Imagine you have a cup sitting on a table and a character that wants to pick it up. You could animate the character to bend over and pick it up, but what if the character is slightly to the side? Or any number of other slight offsets that a player could cause, completely throwing off your animation. It is simply impractical to animate for every possibility. With IK, it hardly matters that the character is slightly off. We just define the goal point for the hand and leave the arm to the IK system. It calculates for us how the arm needs to move in order to get the hand to the cup. Another fun use is making characters look at interesting things as they walk around a room. A guard could track the nearest person, the player character could look at things that they can interact with, or a tentacle monster could lash out at the player without all the complex animation. This will be an exciting one to play with.
Mecanim: Sync Layers & Additional Curves
Sync layers, inside Mecanim, allow us to keep multiple sets of animation states in time with each other. Say you have a soldier that you want to animate differently based on how much health he has. When at full health, he walks around briskly. After a little damage, it becomes more of a trudge. If health is below half, a limp is introduced to his walk. And when almost dead, he crawls along the ground. With sync layers, we can create one animation state machine and duplicate it to multiple layers. By changing the animations and syncing the layers, we can easily transition between the different animations while maintaining the state machine.
Additional curves are simply the ability to add curves to your animations. This means we can control various values with the animation. For example, in the game world, when a character picks up their feet for a jump, gravity will pull them down almost immediately. By adding an extra curve to that animation, in Unity, we can control how much gravity is affecting the character, allowing them to actually get in the air when jumping. This is a useful feature for controlling such values right alongside the animations, but one could just as easily create a script that holds and controls the curves.
Custom Splash Screen: Though pretty self-explanatory, it is perhaps not immediately evident why this feature is specified, unless you have worked with Unity before. When an application built in Unity initializes on any platform, it displays a splash screen. In Unity Basic this will always be the Unity logo. By purchasing Unity Pro, you can substitute the Unity logo with any image you want.
Build Size Stripping: This is an important feature for mobile platforms. Build size stripping removes all of the excess from your final build. Unity does a very good job at only including the assets that you have created that are used in the final build. With the stripping, it also only includes the parts of the engine itself that are used in the game. This is of great use when you absolutely have to get under that limit for downloading from the cell towers. On the other hand, you could create something similar to the asset bundles. Just let the users buy the framework, and download the assets later.
Realtime Directional Shadows: Lights and shadows add a lot to the mood of a scene. This feature allows us to go beyond blob shadows and use realistic looking shadows. This is all well and good if you have the processing space for it. Most mobile devices do not. This feature should also never be used for static scenery. Instead, use static lightmaps, which is what they are for. But if you can find a good balance between simple needs and quality, this could be the feature that creates the difference between an alright and an awesome game.
HDR, tone mapping: HDR (High Dynamic Range) and tone mapping allow us to create more realistic lighting effects. Standard rendering uses values from zero to one to represent how much of each color in a pixel is on. This does not allow for a full spectrum of lighting options to be explored. HDR lets the system use values beyond this range and process them using tone mapping to create better effects, such as a bright morning room or the bloom from a car window reflecting the sun. The downside of this feature is in the processor. The device can still only handle values between zero and one, so converting them takes time. Additionally, the more complex the effect, the more time it takes to render it. It would be surprising to see this used well on handheld devices, even in a simple game. Maybe the modern tablets could handle it.
Light Probes: Light probes are an interesting little feature. When placed in the world, light probes figure out how an object should be lit. Then, as a character walks around, they tell it how to be shaded. The character is, of course, lit by the lights in the scene but there are limits on how many lights can shade an object at once. Light probes do all the complex calculations beforehand, allowing for better shading at runtime. Again, however, there are concerns about the processing power. Too little and you won't get a good effect; too much and there will be no processing left for playing the game.
Lightmapping with Global Illumination and area lights: All versions of Unity support lightmaps, allowing for the baking of complex static shadows and lighting effects. With the addition of global illumination and area lights, you can add another touch of realism to your scenes. However, every version of Unity also lets you import your own lightmaps. This means, you could use some other program to render the lightmaps and import them separately.
Static Batching: This feature speeds up the rendering process. Instead of spending time on each frame grouping objects for faster rendering, this allows the system to save the groups generated beforehand. Reducing the number of draw calls is a powerful step towards making a game run faster. That is exactly what this feature does.
Render-to-Texture Effects: This is a fun feature, but of limited use. It simply allows you to redirect the rendering of the camera from going to the screen and instead go to a texture. This texture could then, in its most simple form, be put onto a mesh and act like a surveillance camera. You could also do some custom post processing, such as removing the color from the world as the player loses their health. However, that option could become very processor-intensive.
Full-Screen Post-Processing Effects: This is another processor-intensive feature that probably will not make it into your mobile game. But you can add some very cool effects to your scene. Such as, adding motion blur when the player is moving really fast, or a vortex effect to warp the scene as the ship passes through a warped section of space. One of the best is using the bloom effect to give things a neon-like glow.
Occlusion Culling: This is another great optimization feature. The standard camera system renders everything that is within the camera's view frustum, the view space. Occlusion culling lets us set up volumes in the space our camera can enter. These volumes are used to calculate what the camera can actually see from those locations. If there is a wall in the way, what is the point of rendering everything behind it? Occlusion culling calculates this and stops the camera from rendering anything behind that wall.
Navmesh: Dynamic Obstacles and Priority: This feature works in conjunction with the pathfinding system. In scripts, we can dynamically set obstacles, and characters will find their way around them. Being able to set priorities means different types of characters can take different types of objects into consideration when finding their way around. A soldier must go around the barricades to reach his target. The tank, however, could just crash through, should it desire to.
.Net Socket Support: This feature is only useful if you plan on doing fancy things over a user's network. Multiplayer networking is already supported in every version of Unity. The multiplayer that is available, though, does require a master server. With the use of sockets, one could create connections to other devices locally.
Profiler and GPU profiling: This is a very useful feature. The profiler provides tons of information about how much load your game puts on the processor. With this information we can get right down into the nitty-gritties and determine exactly how long a script takes to process. Towards the end of the book, though, we will also create a tool for determining how long specific parts of your code take to process.
Script Access to Asset Pipeline: This is an alright feature. With full access to the pipeline, there is a lot of custom processing that can be done on assets and builds. The full range of possibilities are beyond the scope of this book. But think of it as being able to tint all of the imported textures slightly blue.
Dark Skin: This is entirely a cosmetic feature. Its point and purpose are questionable. But if a smooth, dark-skinned look is what you desire, this is the feature you want. There is an option in the editor to change it to the color scheme used in Unity Basic. For this feature, whatever floats your boat goes.
Before we can create the next great game for Android, we need to install a few programs. In order to make the Android SDK work, we will first install the JDK. Then, we will be installing the Android SDK. After that is the installation of Unity. We then have to install an optional code editor. To make sure everything is set up correctly, we will connect to our devices and take a look at some special strategies if the device is a tricky one. Finally, we will install Unity Remote, a program that will become invaluable in your mobile development.
Android's development language of choice is Java, so to develop for it we need a copy of the Java SE Development Kit, JDK, on our computers. The process of installing the JDK is given in the following steps:
The latest version of the JDK can be downloaded from http://www.oracle.com/technetwork/java/javase/downloads/index.html. So, open the site in a web browser.
Select Java Platform (JDK) from the available versions and you will be brought to a combination of license agreement and type selection page.
Accept the license agreement, and select your appropriate Windows version from the bottom of the list. If you are unsure which to choose, then Windows x86 is usually a safe choice.
Once the download is completed, run the new installer.
A scan, two Next button-clicks, an initialization, and one more Next button will install the JDK to the default location. It is as good there as anywhere else, so once it is done installing, hit Close.
In order to actually develop and connect to our devices, we need to have the Android SDK installed. Having it fulfills two primary requirements. First, it makes sure we have the bulk of the latest drivers for recognizing devices. Second, we are able to use the ADB (Android Debug Bridge). ADB is the system used for actually connecting to and interacting with the device. The process of installing the Android SDK is given in the following steps:
The latest version of the Android SDK can be found at http://developer.android.com/sdk/index.html, so open a web browser and go to the given site.
Once there, scroll to the bottom and select USE AN EXISTING IDE.
Follow that up by clicking on the Download the SDK Tools for Windows button.
You will then be sent to a Terms and Conditions agreement. Read it if you prefer, but agree to it to continue and hit the download button to start downloading the installer.
Once it has finished downloading, start it up.
Hit the first Next button and the installer will try to find an appropriate version of the JDK. You will come to a page complaining about it, if you do not have it installed.
If you skipped ahead and do not have the JDK installed, hit the Visit java.oracle.com button in the middle of the page and go back to the previous section for guidance on installing it. If you do have it, continue with the process.
Hitting Next again will bring us to a page about selecting who to install the SDK for.
Select Install for anyone using this computer, because the default install location is easier to get to for later purposes.
Hit Next twice, followed by Install to install to the default location.
Once it is done, hit Next and Finish to complete the installation of the Android SDK Manager.
If the Android SDK Manager does not start right away, start it up. Either way, give it a moment to initialize. The SDK Manager makes sure that we have the latest drivers, systems, and tools for developing with the Android platform. But first, we have to actually install them.
By default it should select a number of options to install. If not, select the latest Android API, 4.3 (API 18) as of the time of writing this, Android Support Library and Google USB Driver found in Extras. Be absolutely sure that Android SDK Platform-tools is selected. This one will be very important later. It actually includes the tools we need to connect to our device.
Once everything is selected, hit Install packages in the bottom-right corner.
The next screen is another set of license agreements. Every time a component is installed or updated through the SDK Manager, you have to agree to the license terms before it gets installed. Accept all of the licenses and hit Install to start the process.
You can now sit back and relax. It takes a while for the components to be downloaded and installed. Once it is all done, you can close it out. We have completed the process, but you should occasionally come back to it. Periodically checking the SDK Manager for updates will make sure you are using the latest tools and API's.
Perhaps the most important part of this whole book, without which none of the rest has meaning, is installing Unity.
The latest version of Unity can be found at http://www.unity3d.com/unity/download. As of the time of writing this, the current version is 4.2.2.
Once downloaded, launch the installer and click Next until you reach the Choose Components page.
Here, we are able to select the features of Unity installation. None of these options are actually necessary for following the rest of this book, but they warrant having a look at since Unity will ask every time you update or reinstall it.
The Example Project is the current project built by Unity to show off some of its latest features. If you want to jump in early and take a look at what a complete Unity game looks like, leave this checked.
The Unity Development Web Player is required if you plan on developing browser applications with Unity. As this book is focused on Android development, it is entirely optional. It is, however, a good one to check. You never know when you may need a web demo and since it is entirely free to develop for the web using Unity, there is no harm in having it.
The last option is MonoDevelop. It is a wise choice to leave this option unchecked. There is more detail in the next section, but it will suffice for now to say that it just adds an extra program for script editing that is not nearly as useful as it should be.
Once you have selected or deselected your desired options, hit Next. If you wish to follow the book exactly, we will be unchecking MonoDevelop and leaving the rest checked.
Next is the install location. The default location works well, so hit Install and wait. This will take a couple of minutes, so sit back, relax, and enjoy your favorite beverage.
Once the installation is complete, the option to run Unity will be displayed. Leave it checked and hit Finish. If you have never installed Unity before, you will be presented with a license activation page.
While Unity does provide a feature–rich, free version, in order to follow the entirety of this book, one requires to make use of some of the Unity Pro features. At https://store.unity3d.com you have the ability to buy a variety of licenses. To follow the whole book, you will at least need to purchase Unity Pro and Android Pro licenses. Once purchased, you will receive an e-mail containing your new license key. Enter that in the provided text field.
If you are not ready to make a purchase, you have two alternatives. We will go over how to reset your license in the Building a simple application section later in the chapter.
The first alternative is that you can check the Activate the free version of Unity checkbox. This will allow you to use the free version of Unity. As discussed earlier, there are many reasons to choose this option. The most notable at the moment is cost.
Alternatively, you can select the Activate a free 30-day trial of Unity Pro option. Unity offers a fully functioning, one-time installation, and free 30-day trial of Unity Pro. This trial also includes the Android Pro add-on. Anything produced during those 30 days is completely yours, just as if you had purchased a full Unity Pro license. They want you to see how great it is, so you will come back and make a purchase. The downside is the Trial Version watermark that will be constantly displayed in the corner of the game. After the 30 days, Unity will revert to the free version. This is a great option, should you choose to wait before making a purchase.
Whatever your choice is, hit OK once you have made it.
The next page simply asks you to log in with your Unity account. This will be the same account you used to make your purchase. Just fill out the fields and hit OK.
If you have not yet made a purchase, you can hit Create Account and have it ready to go when you do make a purchase.
The next page is a short survey on your development interests. Fill it out and hit OK or scroll straight to the bottom and hit Not right now.
Finally there is a thank you page. Hit Start using Unity.
After a short initialization, the project wizard will open and we can start creating the next great game. However, there is still a bunch of work to do: in connecting the development device. So, for now, hit the X button in the top-right corner to close the project wizard. We will cover how to create a new project in the Building a simple application section later on.
We just installed Unity 3D. The whole book relies on this step. We also had to make a choice about licenses. If you chose to purchase the Pro version, you will be able to follow everything in this book without issues. The alternatives, though, will have a few shortcomings. You will either not have full access to all of the features or be limited to the length of the trial.
Now a choice has to be made about code editors. Unity comes with a system called MonoDevelop. It is similar in many respects to Visual Studio. And, like Visual Studio, it adds many extra files and much girth to a project, all of which it needs to operate. All this extra girth makes it take an annoying amount of time while it starts up, before one can actually get to the code.
Technically, you can get away with a plain text editor as Unity doesn't really care. This book recommends using Notepad++, found at http://notepad-plus-plus.org/download. Free to use, it is essentially Notepad with code highlighting. There are several fancy widgets and add-ons for Notepad++ that add even greater functionality, but they are not necessary for following this book. If you choose this alternative, installing Notepad++ to the default location will work just fine.
The simple device-connection method involves changing a few settings and a little work in the command prompt. It might seem a little scary but if all goes well, you will be connected to your device shortly.
The first thing we need to do is turn on some developer settings on the phone. At the top of the settings page, there should be a Development option; select it. If you do not have that option, look for an Applications option.
Find the Unknown sources check box and check it. This lets us install our development applications on the device.
The next checkbox to be checked is USB debugging. This allows us to actually detect our device from the development environment.
If you are using Kindle, be sure to go into Security and turn on Enable ADB as well.
Tip
There are several warning pop ups that are associated with turning these various options on. They essentially amount to the same malicious software warnings associated with your computer. Applications with immoral intentions can mess with your system and get to your private information. All these settings need to be turned on if your device is only going to be used for development. But, as the warnings suggest, if malicious applications are a concern, turn them off when not developing.
Next, start a command prompt. This can be done most easily by hitting your Windows key, typing
cmd.exe, and hitting Enter.We now need to navigate to the ADB commands. If you did not install to the default location, replace the path in the following commands with the path you installed to.
If you are running a 32-bit version of Windows and installed to the default location, type the following in the command prompt:
cd c:\program files\android\android-sdk\platform-toolsIf you are running a 64-bit version, type the following in the command prompt:
cd c:\program files (x86)\android\android-sdk\platform-tools
Now connect your device to your computer, preferably using the USB cable that came with it.
Wait for your computer to finish recognizing the device. There should be a "Device drivers installed" type of message pop-up when it is done.
The following command lets us see which devices are currently connected and recognized by the ADB system. Emulated devices will show up as well. Type into the command prompt:
adb devicesAfter a short pause for processing, the command prompt will display a list of devices attached along with the unique IDs of all attached devices. If this list now contains your device, congratulations, you have a developer-friendly device. If not, things get a little trickier.
For trickier devices, there are a few general things we can try. If these steps fail to connect your device, you may need to do some special research.
Start by typing the following commands. These will restart the connection system and display the list of devices again.
adb kill-server adb start-server adb devices
If you are still not having any luck, try the following commands. These commands force an update and restart the connection system.
cd ../tools android update adb cd ../platform-tools adb kill-server adb start-server adb devices
If your device is still not showing up, you have one of the most annoying and tricky devices. Check the manufacturer's website for data syncing and management programs. If you have had your device for quite some time, you have probably been prompted to install this more than once. If you have not already done so, install the latest version, even if you never plan on using it. The point is to obtain the latest drivers for your device, and this is the easiest way.
Restart the connection system again using the first set of commands, and cross your fingers.
If you are still unable to connect, the best, professional recommendation that can be made is to Google it. Conducting a search for your device brand with
adbat the end should turn up a step-by-step tutorial specific to your device in the first couple of results. http://www.xda-developers.com/ is also an excellent resource for finding out all about the nitty-gritties of Android devices.
Some of the devices that you will encounter while developing will not connect easily. We just covered some quick steps and managed to connect these devices. If we could have covered the processes for every device, we would have. However, the variety of devices is just too large, and they keep making more.
Unity Remote is a great application created by the Unity team. It allows developers to connect their Android powered devices to the Unity Editor and provide mobile inputs for testing. This is a definite must for any aspiring Unity and Android developer. If you are using a non-Amazon device, acquiring Unity Remote is quite easy. At the time of writing this book, it could be found on Google Play at https://play.google.com/store/apps/details?id=com.unity3d.androidremote. It is free and does nothing but connect to the Unity Editor, so the permissions are negligible.
If, however, you are like the ever-growing Amazon market or seek to target Amazon's line of Android devices, adding Unity Remote becomes a little trickier. First, you need to download the APK. It can be found at: http://files.unity3d.com/ricardo/AndroidRemote.apk. Be sure to download the file to a location that you can easily get the whole file path for. In the next section, we build a simple application and put it on our device. Follow along from the Start Console step, replacing the simple application with the downloaded APK.
To make sure everything is set up properly, we need a simple application to test with, and what better to do that with than a Hello World application?
The first step is pretty straightforward and simple; start Unity.
If you have been following along so far, once it is done you should see a screen resembling the next screenshot. As the tab might suggest, this is the screen through which we open our various projects. Right now, though, we are interested in creating one, so select Create New Project from the second tab on top, and we will do just that.
Use the Browse button to select an empty folder to keep your project in. Be sure that the folder is empty, because Unity will delete everything in it before creating the new project.
Ch1_HelloWorld_CSworks well for a project name.
For now we can ignore the packages. These are bits of assets and functionality provided by Unity. They are free for you to use in your projects.
Hit the Create button, and Unity will create a brand new project for us.
The default layout of Unity contains a decent spread of windows needed to create a game.
Starting from the left-hand side, Hierarchy contains a list of all the objects that currently exist in our scene. They are organized alphabetically and are grouped under parent objects, if any.
Next to that is the Scene view. This window allows us to edit and arrange objects in the 3D space. In the top-left hand side, there are two groups of buttons. These affect how you can interact with the Scene view.
The button on the far left that looks like a hand lets you pan around when clicking and dragging with the left-mouse button.
The next button over, the crossed arrows, lets you move objects around. Its behavior and the gizmo it provides will be familiar if you have made use of any modeling programs.
The third button changes the gizmo to rotation. It allows you to rotate objects.
The fourth button is for scale. It changes the gizmo as well.
The second to last button toggles between Pivot and Center. This will change the position of the gizmo used by the last three buttons to be either at the pivot point of the selected object, or at the average position point of all the selected objects.
The last button toggles between Local and Center. This changes whether the gizmo is orientated parallel with the world origin or rotated with the selected object.
Underneath the Scene view is the Game view. This is what is currently being rendered by any cameras in the scene. It is what the player will see when playing the game and is used for testing your game. There are three buttons that control the playback of the Game view in the upper-middle section of the window.
The first is the Play button. It toggles the playing of the game. If you want to test your game, press this button.
The second is the Pause button. While playing, pressing this button will pause the whole game, allowing you to take a look at the game's current state.
The third is the Step button. When paused, this button will let you progress through your game one frame at a time.
On the right-hand side is the Inspector window. This displays information about any object that is currently selected.
In the bottom left-hand side is the Project window. This displays all of the assets that are currently stored in the project.
Behind it is the Console. It will display debug messages and compile errors, warnings, and runtime errors.
At the top, underneath Help is an option called Manage License.... By selecting this, we are given options to control the license. The button descriptions cover what they do pretty well, so we will not cover them in more detail at this point.
The next thing we need to do is connect our optional code editor. At the top, go to Edit followed by Preferences..., which opens the following window:
By selecting External Tools on the left, we can select other software to be used for managing asset editing.
If you do not desire to use MonoDevelop, select the drop-down list to the right of External Script Editor and navigate to the executable of Notepad++, or the other code editor of your choice.
Your Image application can also be changed here to Adobe Photoshop CS3 or any other image-editing program you prefer, in the same way as the script editor.
If you installed the Android SDK to the default location, do not worry about it. Otherwise, click on Browse... and find the
android-sdkfolder.Now, for the actual creation of this application, right-click inside of your Project window.
From the new window that pops up, select Create and C# Script from the menu.
Type in a name for the new script,
HelloWorldwill work well, and hit Enter twice: once to confirm the name and once to open it.Tip
Because this is the first chapter, it will be a simple Hello World application. Unity supports C#, JavaScript, and Boo as scripting languages. For consistency, this book will be using C#. If you, instead, wish to use JavaScript for your scripts, copies of all of the projects can be found with the other resources for this book and an
_JSsuffix for JavaScript.Every script that is going to attach to an object inherits from MonoBehaviour. JavaScript does this automatically, but C# scripts must define it explicitly. However, as you can see from the default code in the script, we do not have to worry about setting this up initially; it is done automatically. Inheriting from MonoBehaviour lets our scripts access various values of the game object, such as the position, and lets the system automatically call certain functions during specific events in the game, such as the Update cycle and the GUI rendering.
For now we will delete the
StartandUpdatefunctions that Unity insists on including in every new script. Replace them with a bit of code that simply renders the words Hello World in the top-left corner of the screen. You can now close the script and return to Unity.public void OnGUI() { GUILayout.Label("Hello World"); }Drag the
HelloWorldscript from the Project window and drop it on the Main Camera object in the Hierarchy window. Congratulations, you have just added your first bit of functionality to an object in Unity.If you select the Main Camera in Hierarchy, then Inspector will display all of the components attached to it. At the bottom of the list is your brand new
HelloWorldscript.Before we can test it, we need to save the scene. To do this, go to File at the top, and select Save Scene. Give it a name of
HelloWorldand hit Save.You are now free to hit the Play button in the upper-middle section of the editor and witness the magic of Hello World.
We now get to build the application. At the top, select File followed by Build Settings....
By default the target platform is PC. Under Platform, select Android and hit Switch Platform in the bottom-left corner of the Build Settings window.
Underneath the Scenes In Build box, there is a button labeled Add Current. Click on it to add our currently opened scene to the build. Only scenes that are in this list and checked will be added to the final build of your game. The scene with the number zero next to it will be the first scene loaded when the game starts.
There is one last thing to change before we can hit the Build button. Select Player Settings... at the bottom of the Build Settings window.
The Inspector window will open Player Settings for the application. From here we can change the splash screen, icon, screen orientation, and a handful of other technical options.
At the moment, there are only a few options that we care about. At the top, Company Name is the name that will appear under the information about the application. Product Name is the name that will appear underneath the icon on your Android device. You can largely set these to anything you want, but they do need to be set immediately.
The important setting is Bundle Identifier underneath Other Settings. This is the unique identifier that singles out your application from all other applications on the device. The format is
com.CompanyName.ProductName, and it is good practice to use the same company name across all of your products. For this book, we will be usingcom.TomPacktAndBegin.Ch1.HelloWorldfor Bundle Identifier, opting to use an extra dot for organization.Go up to File and click on Save again.
Now you can hit the Build button in the Build Settings window.
Pick a save location and a file name;
Ch1_HelloWorld.apkworks well. Be sure to remember where it is, and hit Save.If, during the build process, Unity complains about where the Android SDK is, select the
android-sdkfolder inside the location where it was installed. The default would beC:\Program Files\Android\android-sdkfor 32-bit Windows andC:\Program Files (x86)\Android\android-sdkfor 64-bit Windows.Once the loading bar finishes, which should not be very long, your
apkhas been made and we are ready to continue.We are finished with Unity for this chapter. You can close it down and start a command prompt.
Just as we did when we were connecting our devices, we need to navigate to the
platform toolsfolder in order to connect to our device. If you installed it to the default location, use:For 32-bit Windows:
cd c:\program files\android\android-sdk\platform-toolsFor 64-bit Windows:
cd c:\program files (x86)\android\android-sdk\platform-tools
Double-check to make sure that the device is connected and recognized using:
adb devicesNow we install the application. This command tells the system to install an application on the connected device. The
-rindicates that it should override if an application is found with the same Bundle Identifier as the application we are trying to install. That way you can just update your game as you develop, rather than uninstalling before installing the new version each time you need to make an update. The path to the.apkfile that you wish to install is shown in quotes as follows:adb install -r "c:\users\tom\desktop\packt\book\ch1_helloworld.apk"Replace it with the path to your apk file; capital letters do not matter, but be sure to have all the correct spacing and punctuations.
If all goes well, the console will display an upload speed when it has finished pushing your application to the device and a success message when it is finished installing. The most common causes for errors at this stage are not being in the
platform-toolsfolder when issuing commands and not having the correct path to your.apkfile surrounded by quotes.Once you have received your success message, find the application on your phone and start it up.
Now, gaze in wonder at your ability to create Android applications with the power of Unity.
We created our very first Unity and Android application. Admittedly, it was just a simple Hello World application, but that is how it always starts. Also, it served very well for double-checking the device connection and for learning about the build process without all of the clutter from a game.
Try changing the icon for the application. It is a fairly simple procedure that you will undoubtedly want to perform as your game develops. How to do this was mentioned earlier in this section. But, as a reminder, take a look at Player Settings. Also, you will need to import an image. Take a look under Assets, in the menu bar, to know how to do this.
There were a lot of technical things in this chapter. First, we discussed the benefits and possibilities when using Unity and Android. That was followed by a whole lot of installation; the JDK, the Android SDK, Unity 3D, and Unity Remote. We then figured out how to connect to our devices through the command prompt. Our first application was quick and simple to make. Finally, we built it and put it on a device.
The next chapter will see us creating a game that is significantly more interactive, Tic-tac-toe. We will be exploring the wonderful world of graphical user interfaces. So, not only will we make the game, but we will make it look good too.
