Download the unity 3d app for android. Using Unity to develop applications. How to create games in Unity
Developing games for Android OS devices requires an approach similar to developing for iOS. On the other hand, the hardware of Android devices is not subject to clear standards, which makes it necessary to solve issues that are absent when working with iOS. There are also differences between the Android and iOS versions of Unity.
Preparing the Android Development Environment
Before you can test your games on the device, you will need to prepare your development environment. In particular, download and install the Android SDK of the desired platform and add your device to the system (this process is different for Windows and Mac). This is written in detail on the Android developers website, and additional information may be provided by the manufacturer of your device. Since this is a rather complicated process, we have prepared a small instruction that will help you prepare everything you need for development. If you need more information, you can get it from the Android Developer Portal.
Access to Android features
Unity provides an API for accessing Android input and settings. The available classes are documented in the Code for Android Assemblies page.
Linking C, C++ or Java code to scripts
Unity allows you to call functions written in C/C++ directly from scripts (Java functions can be called indirectly). To learn how to access functions from native code from Unity, visit the Android plugin building page.
Occlusion Culling (clipping invisible geometry)
Unity provides support for occlusion culling, which is very useful when optimizing for mobile platforms. More information can be found on the Occlusion culling page.
Customizing the startup screen
The splash screen displayed when the game starts can be customized - see this page for more information.
Troubleshooting and Error Reporting
There are many reasons why your app is crashing or not working properly. Our guide to solving Android-specific problems will help you deal with the causes of errors in the shortest possible time. If, after reading the manual, you assume that the problem is in Unity, you should file a bug report. Refer to this page for instructions.
How Unity for Android differs from the desktop version
JavaScript with strong typing
To improve performance in the Android version of Unity, dynamic typing in JavaScript is always disabled (as if #pragma strict were automatically applied to each script). This is important to remember if you are porting a project to Android from older platforms, and if you encounter compilation errors, the problem should be looked for first of all in typing. Such errors are usually easy to deal with by making sure that the types of all variables are explicitly specified or cast during initialization.
While Unity Android supports DXT/PVRTC/ATC textures, Unity will decompress textures to RGB(A) format on runtime if these compression methods are not supported on the specific device. This can seriously affect GPU rendering performance, so it is recommended to use the ETC format. It is the de facto standard for Android and should be supported by all modern devices. On the other hand, ETC does not support an alpha channel, and sometimes 16-bit RGBA textures will be the best choice in terms of quality, size, and rendering speed where an alpha channel is needed.
Post Views: 19 374
We talked about how you can create your own game on Android using the Unreal Engine. In this article, we will look at another equally popular game development engine - unity.
Unity is a very famous engine among indie developers. In fact, it is a cross-platform engine that allows you to develop 3D- and 2D-games. The feature that sets Unity apart from other engines is the low entry threshold for beginners, while having a rich toolkit for professionals. Cross-platform allows you to develop applications for any platform, from desktop games to mobile ones.
Separately, it is worth mentioning the subscription system, since Unity is not a completely free product. There are several types of subscriptions:
- Personal. Free version that contains all the main features of the engine. It has the following limitation: income per year or the amount of funds raised must not exceed 100000$ .
- Plus. Per $35 per month various reports and analytics are provided, as well as the ability to change the splash screen, 20% -th discount on purchases in Asset Store and various minor benefits. It has the following limitation: the income for the year or the amount of funds raised must not exceed 200000$ .
- Pro. Per $125 per month includes all the benefits of the version Plus and additionally professional service and premium support. No restrictions on turnover or amount of funds.
- Separate versions for business (used by large companies).
Thus, indie developers with small budgets should be satisfied with the version Personal or Plus otherwise you will need to subscribe Pro. In this article, we will use free version for the first run.
Step 1Install Unity
In order to start installing Unity, you need to go to the Unity Store website, where you will be prompted to select the type of subscription. As mentioned above, we choose Personal.
You will then be prompted to accept the terms of use and download the installer. You can also check out system requirements to work with Unity.
After launching the installer, you will be prompted to select which components to install. Since we need to create an Android application, we will check the box for Android Build Support. Also, if desired, instead of with Unity, you can install Visual Studio Community 2017 for programming on C#.
After that, all that remains is to choose the installation path and start installing Unity.
Step 2: Registering and Setting Up Unity
After completing the installation and running Unity, we are prompted to log in with our account.
Then again you will be asked to select a subscription, we will also focus on Personal. In this case, you will need to confirm that the company's annual income is less than $100,000, or that Unity is used for training purposes.
At the end, it is proposed to take a small survey in which you need to answer what you do and for what purpose you install Unity.
Step 3. Create a new project
Having configured Unity, we get to the screen for selecting / creating a project. Click here New to create your new project.
After that, in the window that appears, you are asked to enter the name of the project and the directory where it will be located. Also don't forget to check the box 3D to use the editor in 3D mode.
When done with this, click Create project to create a project. After that, an editor window will open with a pre-generated scene.
We will not yet deal with the intricacies of programming and take for example finished game. For this there is Asset Store, which contains a huge number of ready-made models, animations, sounds (and even games), both paid and free.
To open the Asset Store, you need in the menu Window choose Asset Store(key combination ctrl-9).
The store window will open. Enter in the search bar " flappy bird style example game" and open a free example that we will use in our project.
Clicking Download and thus having downloaded it, you can then import it into your project. To do this, click Import, after which a warning will appear that the project settings will be changed after import.
After agreeing to import, you will see a window in which you need to choose which components to import. Select all and click Import.
Once the import is complete, you will see the new files in the Project Browser. These are the game files. To open the scene in the editor, expand Flappy Bird Style - scenes and double click on Main.
As a result, the game scene will appear in the 3D editor window.
You can check how the game works right in Unity by clicking on the button play above the editor window.
Step 4Configure Android Tools
Note: if you are using android studio, then you already have everything installed necessary components and so you can safely move on to the next step.
In order to assemble the resulting game on Android, you need to install the following tools:
- Java Development Kit (JDK). You can download it from the Java website. By clicking on the link, you will see at the very top Java Platform (JDK), click on Download next to the inscription, then select your operating system and start downloading. After that just follow the instructions of the installer.
- Android SDK. by the most in a simple way to install the latest version is to download the Android Studio with which this SDK comes. To do this, go to the Android Studio website and click Download Android Studio. The Android Studio installer installs the core Android SDK components required for Android development.
Step 5. Prepare the project for launch
First, you need to change the development platform to Android. To do this, in Unity, open the File menu and select Build Settings.
In the window that appears, select Android and then press switch platform.
The platform switch tells us that we will be building an Android app. This means that when we build the application, Unity will create APK file. The platform switch also forces Unity to re-import all assets in the project. This won't take long on a small project, but keep in mind that this operation can take a long time on large projects.
Now we need to provide a package name for the application.
Note: The package name is a unique identifier for the application and is written in reverse DNS style in the format com.CompanyName.ProductName. Once the app is published on Google Play, the package name can no longer be changed.
To do this, go to the menu Edit and choose Project Settings - Player.
On the right side of Unity, a window will open with many different settings, such as the application version, target and minimum SDK, icon selection, etc. Here we need in the block Other Settings find Identification and set the package name in the field package name. You can also change other settings if you wish.
Now it remains only to specify the path to the Android SDK and JDK. To do this, go to the menu and select Edit-Preferences.
In the window that appears, go to External Tools and in the fields SDK and JDK specify the appropriate paths, and then close the window.
Step 6: Building and Running the Application
It's time to build your first Unity app. To do this, select from the menu File - Build Settings. A window will open, in which you will need to add the scene that you want to assemble. Since we already have this scene open in the editor, just click Add Open Scenes to add it to the assembly, after adding it you will see it in the list of scenes.
It remains only to press Build, after which Unity will start building the application. Before that, you may be asked to select a folder where the collected application files will be saved, as well as the name of the APK file.
Note: at the moment, if you have the alpha version installed in the Android SDK Build-Tools(version 28.0.0-rc1), when building Gradle will give an error. To fix this, simply remove this version from the Android SDK.
As a result, the built APK file will appear in the folder you specified, ready to be installed on the emulator or on a real device.
Let's see what's inside the built APK. To do this, we use the utility APK Analyzer, which is included with Android Studio,
The uncompressed APK file size is 21.1MB, in a compressed 20.9MB. As you can see from the graph, most of the volume is occupied by third-party libraries added by Unity. Then in assets all the resources that are used in the assembled scene are located. File classes.dex contains only 89 classes and 479 methods.
Moreover, if you look at AndroidManifest.xml, the application consists of one activity.
Conclusion
That's all. In this article, we learned how to install and configure Unity, and also built our first Android app.
Unity is the engine on which most of the modern games on different platforms. Through the engine, it is really possible to create games that are oriented to run on computers (Windows, Linux, MacOS), mobile phones, tablet computers (Android, iOS) and even game consoles PlayStation, Xbox, Nintendo.
How to create games in Unity?
Unity is based on a component-oriented concept. In fact, any game consists of a mass of objects diluted with additional components. For example, during the creation of a platformer, we create a GameObject, additionally attach a graphic component to it, which is responsible for displaying the character, and a control component, it provides control of the character using a mouse, keyboard, joystick or touchscreen. The engine does not impose restrictions on the number of such modules. We can add as many components to the GameObject as needed. All work on the engine is based on the very creation of GameObject and the application of suitable components to them.
Beginners may be misled by the apparent simplicity of the process, although this is not the case. To create a unique and popular game, you have to write a lot of components from scratch. More specifically, in the Unity environment, this is called a script. The native scripting language is C#, but JavaScript and Boo (a cropped version of Python) are also partially used. Creating your own components is not easy, one might even say it is a complex procedure, directly tied to classical programming. Without a sufficient level of knowledge in programming, it will be hard.
Supported Platforms
Many large projects prefer Unity because of the huge list of platforms compatible with the engine. The finished application can be launched on any computer operating system, popular mobile platforms and SmartTV. What can we say, even browser games and applications for specific platforms ( like Tizen OS) are predominantly developed in Unity.
However, not everything is so smooth here. If necessary, you can write specific algorithms based on low-level code, for the same Android you need to have a thorough knowledge of Java.
The same is true for iOS. Another feature of iOS is that it is possible to develop for it only from a computer or tablet from Apple. In the absence of a Macbook or similar device, the release of the game will quickly stall and Unity has nothing to do with it, Apple itself imposes a similar restriction. The conclusion is simple: if there is an iOS development in the plans, you should choose a suitable device for assembly in advance.
How and where to develop a game on the engine?
We can carry out a long process of game development both within Windows and Mac OS X. There are already versions of the editor for Linux, but so far we cannot count on their stable operation. A developer spends most of the time creating a game inside the Unity editor. We still have a lot of time to write script code, we can create it either in the standard MonoDevelop or in any third-party editor. Now they actively use Visual Studio, as well as Sublime Text, but only with proper configuration.
Development mobile applications is one of the most profitable occupations in the computer industry. Creating an Android game costs hundreds or thousands of dollars, and the profit can reach up to a million dollars. In this regard, many people are interested in developing applications for the phone. In this article, you will learn how to create an Android game from scratch using a computer, which engine and designer is better to choose.
None successful game can not do without beautiful graphics, so the creation of design is one of the most important stages of development. Design on the Android OS is implemented using a “design document” or design document. You need to start creating a toy with its detailed study. The file contains:
- Object models;
- Functional specifications;
- Game content;
- Interface.
Let's consider each of the points in more detail.
Object models
This is information about the functionality of each item. Object models are responsible for the ability to buy and sell items, as well as for improving the game characteristics of characters.
Functional specifications
It describes the gameplay, the main features of each character. It also describes the features game items- weapons, first-aid kits, armor and others. Essentially, functional specifications are the rules by which game process. The better this section is worked out, the easier it will be to create a high-quality Android game.
Game content
This is the text filling of the game. It describes the dialogues of the characters and what weapons can be used to deal damage, how much health a hit will take, what characteristics will increase when using various equipment. It also contains detailed description each item.
Interface
The interface is how the user will interact with the game. It includes buttons with which you can control the character, and menu sections: for example, play, score, settings, top players, help. If you have no experience in creating Android applications, before creating your own, download from the Play Market and analyze popular games and transfer the best solutions to your project.
Game engine
The core of any game is the engine. it software, allowing you to develop and run it. It contains a whole range of programs, including a rendering engine, a physics engine, sound, animation, and much more. To facilitate the process of writing programs, third-party developers create their own game engines specifically for Android applications.
Each of them offers different features: some are designed for 3D, others for 2D, multi-platform can be supported. There are a huge number of such engines, but if you are a beginner, it is better to choose one of the most popular ones, since all the necessary functions will be present there.
UDK
Torque 2d/3d
What is a game designer?
Constructor is a program that combines a game engine and an integrated development environment. The constructor makes the development process accessible to people who do not have programming skills. Some of the designers allow you to create games of certain genres, others have maximum functionality, but cost much more money. For a novice creator of mobile applications, the choice of a designer is one of the most crucial moments, because the fate of the future application will depend on its capabilities.
The constructor allows you to create games of various genres for Windows, Android and iOS. Offers big choice ready-made locations, objects, characters and sound design, so the creation of the first Android game will not take much time. Users familiar with the JS and C++ programming languages can use the embedded GML. The only drawback is that the program is not translated into Russian.
Conclusion
Creating an Android game is not an easy, but very profitable business. If you decide to develop a game and make money on it, first work out the idea. Next, write a “design document” and decide on a game engine that can maximize its potential. After that, you can proceed directly to creating the application in the constructor.
Video
To learn more about the process of creating Android games, check out a series of videos dedicated to this activity.
How to quickly write an Android game with Unity
At the present time, anyone can become a successful mobile game or application developer without making a titanic effort. An example of such a case is Dong Nguyen, who developed Flappy Bird. The game did not have any complex mechanics or graphics, but this did not prevent it from becoming popular and bringing its creator fifty thousand dollars a day. However, there was nothing remarkable about the game. All it took to be successful was to be in the right place at the right time and a little bit of luck. Similar things can happen today, you just need the right idea.
To demonstrate how easy it is to write something like this, today we will write our own Flappy Bird using Unity in just 10 minutes.
game character
First create a new project and make sure the 2D option is selected.
Load your bird sprite into the scene. Don't forget to turn on your imagination!
Then adjust the size of the sprite to your liking by dragging it around the corner in the direction you want. The sprite should be visible in the hierarchy window on the left. All objects in the scene are visible in it, and at the moment there should be only two of them: a camera and a bird.
Drag the camera to the bird and release. The camera should be under the bird, which means that the camera is now the "child" of the bird. Now the camera position will be fixed relative to the bird. If the bird moves forward, then the camera does the same.
Select the bird again in the scene or in the hierarchy window. You will see a list of options and attributes on the right in a window called Inspector . Here you can manage various variables bound to a particular object.
Now click on Add Component . Select Physics2D > Rigidbody2D - this is ready set instructions for applying gravity to our character. Click on Constraints in this panel and then select freeze rotation Z . This will prevent the bird from rotating around with the camera.
In the same way, add a Polygon Collider that tells Unity where the character's borders are. Press Play and see how the sprite, along with the camera, falls down endlessly.
So far everything is going well!
Now it's time to start flying the character, since it will not be difficult.
First you need to create a C# script. Create a folder for it (right click somewhere in assets and create a "Scripts" folder), right click and select Create > C# Script .
Let's call it "Character". Double click on it to open it in your IDE, be it MonoDevelop or Visual Studio. Then add the following code:
Public class Character: MonoBehaviour ( public Rigidbody2D rb; public float moveSpeed; public float flapHeight; // This is for initialization void Start () ( rb = GetComponent(); ) // Update is called once per frame void Update () ( rb .velocity = new Vector2(moveSpeed, rb.velocity.y); if (Input.GetMouseButtonDown(0)) ( rb.velocity = new Vector2(rb.velocity.x, flapHeight); ) if (transform.position.y > 18 || transform.position.y< -19) { Death(); } } public void Death() { rb.velocity = Vector3.zero; transform.position = new Vector2(0, 0); } }
This code does two things. It makes the character move forward at a speed that we define in the inspector and gives the impression of a bird in flight. The Update() method is called repeatedly throughout the game, so whatever you put here will run continuously. In this case, we are adding some speed to our object. The rb variable is the RigidBody2D script we applied to our object earlier, so when we write rb.velocity we are referring to the object's velocity.
A tap on the screen is interpreted by Unity as a mouse click if you are using a mobile device. After pressing, we force the character to rise up a little.
The variable moveSpeed will be responsible for the speed of movement, and the variable flapHeight - for increasing the height of the bird's flight after each click. Because these variables are public , we can change them outside of the script.
The Death() method is also declared public , which means that other objects and scripts can call it. This method simply returns the position of the character to the start. It will also be used every time the character flies too high or low. You will soon understand why it is declared as public . The line rb.velocity = Vector3.zero; needed to remove momentum - we don't want the character to fall faster and faster after each death, right?
Now you can exit the IDE and add the script as a component to the character. To do this, select our bird and click Add Component > Scripts > Character . Now we can define moveSpeed and flapHeight in the inspector (that's what the public variables are for). Assign variable values 3 and 5, respectively.
And one more thing: in the inspector, you need to add a tag to the character. To do this, click where it says Tag: Untagged and then select Player from the dropdown list.
Obstacles
Now let's add obstacles: pipes. Someone finds mushrooms in the pipes, and someone finds his own death.
Drag the pipe sprite into the scene to where you want the first obstacle to be and name it pipe_up .
Now let's create a new script called Pipe:
Public class Pipe: MonoBehaviour ( private Character character; // Needed for initialization void Start () ( character = FindObjectOfType(); ) // Update is called once per frame void Update () ( if (character.transform.position.x - transform.position.x >
Add this script to the pipe sprite in the same way as before. Thus, the pipe will return to the screen after leaving its left border. We haven't done anything here yet, but we'll get back to it.
The OnCollisionEnter2D() method is called each time the pipe interacts with a character. After that, the Death() method created earlier is called, returning the player to the starting point.
So, we have one pipe that will disappear from time to time and reappear at the other end of the screen. Hit her, you die.
inverted pipes
Right now we only have one pipe sprite. Let's add one more. To do this, right-click in the hierarchy window, click New 2D Object > Sprite, and then select the sprite you want to use. It's even easier to just drag the file into the scene again.
Name this sprite pipe_down . In the Inspector, under Sprite Renderer, select the Flip Y option to flip the pipe upside down. Add the same RigidBody2D .
Now let's write a new C# script called PipeD . It will have similar code:
Public class PipeD: MonoBehaviour ( private Character character; //This is needed for initialization void Start() ( character = FindObjectOfType(); ) // Update is called once per frame void Update() ( if (character.transform.position.x - transform.position.x > 30) ( ) ) void OnCollisionEnter2D(Collision2D other) ( if (other.gameObject.tag == "Player") ( character.Death(); ) ) )
Prefabs
So, this code is enough for us to make the whole game. We could move the pipes to the right side of the screen every time they disappear, or copy and paste as many pipes as we'd like throughout the game.
If you go the first way, then making sure that the pipes are right after random generation, and it would be difficult to maintain a fair course of things. After the death of the character, they could appear in kilometers from the first pipe!
If you go the second way, then everything will end up with excessive memory consumption, with the resulting slowdown in the game, and limited replay value, because. everything stays in the same place every time.
Instead, let's use prefabs. In simple terms, we will turn our pipes into templates that we can then use to effectively create more pipes as desired. If there are programmers here, then consider the Pipe script as a class, and pipes as instances of this object.
To do this, create a new "Prefabs" folder. Then drag pipe_up and pipe_down from the hierarchy window to the folder.
Every time you drag an object from this folder into the scene, it will have the same properties, so you don't have to keep adding components. What's more, if you resize a component in a folder, it will affect all pipes in the game, and you won't have to resize each one individually.
As you can imagine, this will greatly save our resources. It also means that we can interact with objects from code. We can instantiate our pipes.
First, add this code to the conditional expression in the Update() method of the Pipe script that we left empty:
Void Update () ( if (character.transform.position.x - transform.position.x > 30) ( float xRan = Random.Range(0, 10); float yRan = Random.Range(-5, 5); Instantiate (gameObject, new Vector2(character.transform.position.x + 15 + xRan, -10 + yRan), transform.rotation); Destroy(gameObject); ) )
This is needed to create an instance of our gameObject . The result is a new identical copy. In Unity, whenever you use the word gameObject , it refers to the object the script is currently bound to - in our case, the pipe.
We re-generate our pipes in random variations to make it more fun.
But instead of doing all the same in the PipeD script, we generate both objects in the same place. Thus, we can easily set the position of the second pipe relative to the first. It also means we need less code for PipeD .
Create a public gameObject named pipeDown . Then update the code like this:
If (character.transform.position.x - transform.position.x > 30) ( float xRan = Random.Range(0, 10); float yRan = Random.Range(-5, 5); float gapRan = Random.Range (0, 3); Instantiate(gameObject, new Vector2(character.transform.position.x + 15 + xRan, -11 + yRan), transform.rotation); Instantiate(pipeDown, new Vector2(character.transform.position.x + 15 + xRan, 12 + gapRan + yRan), transform.rotation); Destroy(gameObject); )
Go back to Unity and drag the pipe_down prefab from the prefabs folder (this is important!) to the place where it says "Pipe Down" (notice how our camel case is replaced with a space) onto the pipe sprite pipe up . If you remember, we defined Pipe Down as a public gameObject , which gives us the ability to determine what this object is from anywhere - in this case through the inspector. By choosing a prefab for this object, we make sure that when the pipe is instantiated, it will include all the attributes and script that we added earlier. We don't just create a sprite, but we recreate an object with a collider that can kill the character.
All we'll add in the same place in the PipeD script is just Destroy(gameObject) , so that the pipe will self-destruct when it goes off the left side of the screen.
If you start the game now, the screen will advance automatically and you will die if you hit any of the pipes. Fly far enough and those pipes will disappear and reappear ahead.
Unfortunately, there is a large distance between the pipes and the screen looks blank. We could fix this by adding some prefabs to our scene to create a pipeline of constantly spawning pipes. However, it would be better to generate the pipes in a script. This is important, because otherwise, after the death of the character, the pipes at the beginning of the path will be destroyed, and empty space will again form.
In this way, we can create the first few pipes during each game load and return everything to its place after the death of the character.
Endless flight
Now let's create the public variables pipe_up and pipe_down in the Character script. This will give you the ability to reference the created objects by dragging prefabs onto the character object, just like when we added pipe_down to the Pipe script.
We need to add these variables:
Public GameObject pipe_up; public GameObject pipe_down;
Then we'll write a method like this:
Public void BuildLevel() ( Instantiate(pipe_down, new Vector3(14, 12), transform.rotation); Instantiate(pipe_up, new Vector3(14, -11), transform.rotation); Instantiate(pipe_down, new Vector3(26, 14), transform.rotation); Instantiate(pipe_up, new Vector3(26, -10), transform.rotation); Instantiate(pipe_down, new Vector3(38, 10), transform.rotation); Instantiate(pipe_up, new Vector3( 38, -14), transform.rotation); Instantiate(pipe_down, new Vector3(50, 16), transform.rotation); Instantiate(pipe_up, new Vector3(50, -8), transform.rotation); Instantiate(pipe_down, new Vector3(61, 11), transform.rotation); Instantiate(pipe_up, new Vector3(61, -13), transform.rotation); )
We will call it once in the Update() method and once in the Death() method.
After the game starts, Update() is called, and our pipes are placed according to the given configuration. Due to this, the first few obstacles will always be in the same place. After the death of the player, the pipes will return to the same places.
Return to the scene in Unity and delete the two pipes that are now there. Your "game" will just look like a blank screen with a bird. Press Play and the pipes will appear, after the first few, their position will be determined randomly.
Finally
That's what we did whole game! Add a score counter, try to make it more original and increase the difficulty of the game as you progress. Also, it will not be superfluous to make a menu. Another good idea is to destroy the pipes on the screen after the death of the character. Once you're done with that - consider it ready for release in Play Store game in your pocket! Once upon a time similar game made another developer very rich, which proves that you don't have to be a programming genius or have a rich publisher behind you to be successful. You just need a good idea and ten minutes!
Want to write Android apps but don't know where to start? Then check out our great tutorial for learning Android development.
