Tips to Avoid Common Mistakes in Mobile Game Development

In this blog we will highlight a number of pitfalls and mistakes that we have encountered during our mobile game developing experience, and help you avoid them. We have developed two mobile games on the Android platform. One is called Thirsty Plant, and the other is called Plash as shown in the videos below. Please check them out on your Android device! Alright let’s get started. 

1- Determine Your Game’s Target Platforms Early

Before you start your development journey, confirm which platforms you want to target. The most popular are iOS and Android. This will put you in the mindset of writing cross-platform compatible code from the outset. If you write code only for Android, then later on you decide to publish the game on iOS as well, you might have to modify the code. This will cost you additional time, as you will have to write new code and retest your game across all platforms to ensure you did not introduce new bugs.  

This is particularly important if you’re using third party libraries. For example, if you’re integrating an in-app purchases library, the implementation will likely vary between iOS and Android. 

The good news is that modern game engines, like the Unity engine, make it easy to develop games on multiple platforms with minimal code changes. 

2- Determine Your Game’s Target Screen Orientation

Mobile games can work in multiple screen orientations, decide which orientation your game should support: landscape, portrait or both. Some games are more suitable for a specific orientation. For instance, racing games are typically locked in landscape mode, allowing the player to use their phone as a steering wheel by tilting the device to control the vehicle. Both of our games are locked in portrait mode because their gameplay is better suited to a vertical orientation.

Keep in mind that supporting both orientations will require more time and effort for several reasons:

1. UI adjustments: Your User Interface (UI) design will need to handle screen orientation change properly. Otherwise, the UI elements might overlap, stretch or obstruct the view.
2. Camera adjustments: Your code will likely need to adjust the camera’s Field of View (FOV) for a perspective camera or the Orthographic Size for an orthographic camera. Otherwise, your game view might appear stretched or shrunk. 
3. Input handling adjustments: The input handling will need to adapt as well. If you have buttons, their position will need to be carefully placed on both orientations to give the player a good user experience.
4. Scene adjustments: The layout of the scene may need adjustments when the orientation changes. For example, in portrait mode, the game might display a sky to fill the vertical space. When switched to landscape, the additional horizontal space will need to be filled with, for example, foliage or buildings. 
5. Performance: As illustrated in point 4, supporting both orientations will require loading additional assets, which can impact performance. Proper asset and memory management is crucial to maintain a smooth gameplay experience.  

3- Verify Library Version Compatibility With App Store Requirements

App stores like Google Play or Apple’s App Store often set the minimum version requirements for third-party libraries. For example, Google Play has a minimum version requirement for the in-app purchases library. If you develop your code using an outdated version and realize that you need to update it, it will cost you time. Make sure you’re using the latest version, or at least a supported version, from the outset to avoid potential issues down the line.

4- Verify the Minimum and Target API Version Requirements of the App Stores

App stores often set the minimum and target API versions your app can target. Check these requirements early in development. You don’t want to spend time and effort special-casing parts of your code for an older iOS or Android version only to find out later on that these versions are not even supported. On the Unity engine, you can set the target and minimum API by in the Player settings.

5- Use Vector Graphics

Vector graphics are very powerful because their image quality is not affected by scale. Design your game’s icons and logos using vector graphics software such as Inkscape. This will come in handy later on because app stores require different resolutions for icons and logos. For instance, Google Play requires a 512×512 app icon, while Apple’s App Store requires a 1024×1024 size. If you design your icon for Google Play using a raster-based image editor in 512×512 size, you will have to scale it up to 1024×1024 for Apple. This will degrade the quality of your icon. With vector graphics however, you can export images to any size you like. 

6- Do Not Overcomplicate the UI

You might be tempted to create a fancy, complicated UI to impress the player. We certainly fell into this trap. Below, on the left, you can see the elaborate main menu UI we created for our game Plash and compare it to the simple UI we created for our later game Thirsty Plant on the right. We recommend avoiding complicating the UI for the following reasons:

1. Screen size: mobile phones have small screens, so avoid overcrowding it with too many UI elements. Additionally, phones come in different sizes. Your UI might look great on a larger phone, but on a smaller phone, your UI elements might overlap due to insufficient space. It can quickly become a nightmare to have the UI work properly for different screen sizes. 
2. Consistency: If you design an elaborate UI in one menu, like the main menu, you’ll need to maintain the same level of detail across menus like the settings or shop menu. This can quickly become exhausting if your game has multiple menus.
3. Time and effort: You will have to spend a significant amount of time to not only create the textures but also make them work nicely with the limited screen space on mobile.
4. Performance: A fancy UI requires high resolution textures, which can impact performance. The last thing you want is for your game to start experiencing stuttering or low FPS before even starting. That’s a huge turn off for players.

Ultimately, what matters in a UI is functionality. Try to balance visuals with usability and don’t overlook performance.

7- Anchor the UI Elements Properly

In game engines, UI elements have anchors assigned to them, which ensure the element maintains a consistent position relative to its parent container, regardless of screen size. You need to choose this anchor carefully to maintain a consistent UI between different screen sizes.

In the example below, the anchor of the button is at middle-center as shown below in the left image. The middle image shows the button in a 720×1280 screen resolution, while the right image shows the button in a 720×1520 screen resolution. Notice how the UI is inconsistent, the longer phone has more space above the button than the smaller phone. 

Now if we set the anchor to top-center as shown below in the left image, the button will be placed at the same position relative to the top of the screen regardless of screen size as shown in the middle and right images.

8- Check if Your UI Needs a Scroll View

If you’re testing your UI on a large device, it might seem like all is well. However, when you switch to a smaller device, you will realise that the UI is cut off at the bottom because the screen size is too small to fit the whole view. If that’s the case, then you need to use a scroll view.

Also, if your game supports landscape mode, then you will most likely need to add a scroll view as the vertical space is significantly reduced.

9- Make Buttons and Text Large Enough

Try to make your buttons large enough to be easily clickable and your text large enough to be easily readable.

10- Balance Audio Volume Properly

This one is a common oversight in video games. We’ve all experienced playing games where the dialogue audio is too quiet compared to the background music, forcing you to increase the volume but then the music is too loud. Or games where the cutscenes are too loud, giving you a jump scare when they are initiated. 

You need to test your game with the audio on to ensure a comfortable experience. Check for click sounds, sound effects, music, dialogues and any other sounds. Make sure the volumes are well balanced.

11- Add Mute Buttons

No matter how catchy your game’s background music might be, having it loop endlessly can get tiring pretty fast, especially on headphones. Always offer players the option to mute or unmute the background music with a dedicated button. Include a second button to mute the rest of the audio, but avoid a single “mute all” button. This is because players might want to mute the music but keep the sound effects or dialogue audio. 

12- Add Subtitles if Applicable

If you have dialogues or voice audio in the game, then consider adding subtitles for better accessibility. 

13- Include a Simple Onboarding Tutorial

This one is easy to overlook because you, as the developer, are naturally familiar with the ins and outs of your game. It might seem obvious to you how to play the game, but that’s not necessarily the case for first-time players. Include a simple tutorial at the start of the game to introduce the core mechanics. Keep it simple, you only need to include some text and visual indicators.

14- Avoid Asking for Unnecessary Permissions

Avoid requesting unnecessary permissions in your game. For example, if your game doesn’t need to access the phone’s gallery or storage, then there’s no need to ask for these permissions, otherwise players will be confused as to why the game needs them and can discourage players from playing your game. 

15- Explain Why the Game Needs Permissions

If your game requires permissions for a legitimate reason, always explain to the users why they’re needed using a simple popup. Users are more likely to grant access when they understand the purpose behind the request.     

16- Ask Users to Rate Your Game

You’ve probably played mobile games that prompt you with a popup asking you to rate the game. This might seem minor, but it could prove to be crucial for your game’s presence in the app stores. Game developers do this because they know most players won’t bother rating the game unless you ask them. 

Include a simple UI popup in your game that directs players to the game’s app store page to leave a rating or review. Positive reviews might boost your game’s ranking in search results, and encourage more downloads. Negative reviews, on the other hand,  provide valuable feedback for improvement. Don’t ignore them, address the issues and release an updated version. 

However, make sure the popup is not intrusive. Prompt the user at specific times, such as after they’ve achieved a milestone. Do not interrupt the gameplay.  

17- Add a Nice Splash Screen

A splash screen is the first page that appears when you launch the game. A splash screen can give your game a more professional appearance. It’s also a great opportunity to plug your company’s logo and name if you desire. You can add one in the Unity engine in the Player settings.

18- Optimize Game Performance

Once your game’s core mechanics are implemented and you are nearing completion, it’s time to focus on performance optimization. Your game should work smoothly across a wide range of device hardwares to increase your audience. If you want tips on how you can improve performance, check out our blog How to Improve the Performance of Your Unity Game.

19- Optimize Game Size

Some users might be put off downloading your game if its size is too large. As you reach the final stage of development, go through your game assets and remove any unused assets that you don’t need. For tips on how you can reduce image sizes, read our blog How to Improve the Performance of Your Unity Game.

20- Use Version Control

There’s nothing worse than losing hours of work and having to do it all over again. To avoid this, use version control like GitHub to save your work. It will also allow you to track your changes to the project over time. Don’t forget to set the repository to private in the repo’s settings in GitHub if you want to hide the code from the public.

21- Test on Different Screen Sizes

We cannot stress enough how important this is. Developing on mobile is particularly challenging due to the wide range of screen sizes and the fact that phones support both portrait and landscape orientations. Test on as many screen sizes as you can, preferably on physical devices. Of course, it’s not realistic to have five or six phones with different screen sizes laying around, in that case, you can use emulators.

If your game supports both portrait and landscape modes, test in both screen orientations and ensure the UI works as intended. As mentioned before, pay close attention to how your camera behaves when the orientation changes. 

22- Test Game on All Your Targeted Platforms

If you’re publishing your game on multiple platforms, test on all of them. Once again, emulators can help in case you don’t have physical devices. 

23- Test the Game Thoroughly 

Testing games is different from testing other types of apps. Games are less predictive and can fail in multiple ways. Moreover, automating tests in video games is not always practical. For example, unit testing is typically not feasible for testing gameplay. You can however use unit tests for components of the code that are isolated and logic-based. Automated UI tests can also be effective by simulating clicks and comparing the expected outcomes with the actual results. There are various tools and libraries that allow you to do this. So if you can automate some parts of testing, it’s always better than testing everything manually.

The best way to test your game is to simply play the game yourself. Ideally, you would play the game from start to finish and document any bugs that you encounter and fix them.

For tips on debugging Unity games, check our blog Tips for Debugging Unity Games.

24- Set App Icons for Different OS Versions

Your target OS may require different icon sizes for different versions. If you’re developing on Android using the Unity engine, you can navigate to the Icon section in the Player settings to access the app icon settings as shown below on the left.  Here, you can upload icons for different OS versions, each with specific styles like adaptive or round. For example, expanding the adaptive section, for API 26 and above, allows you to upload icons for different screen densities such as xxxhdpi or xxhdpi. Upload an icon for every slot that applies to your game based on the OS versions you plan to support. This will ensure your game icon looks great across different OS versions and screen densities. We mentioned vector graphics earlier, well, this is another area where they will make your life a lot easier.

25- Set the Correct Package Name in the Settings

Before uploading any build to your target app store, including a development build, make sure to finalize the package name in the Player Settings. To set it in the Unity engine, navigate to the Other Settings section in the Player settings and locate the Package Name field as shown below. Setting the package name correctly is important because once you create the project in the app store account, it will ask you to enter it and it’s final, cannot be changed. To change it, you will have to create a new project, so it’s better to avoid this unnecessary headache. 

26- Make Sure to Disable Development Build Before Releasing the Game

This is another mistake that’s easy to miss, before releasing your game to production, make sure to disable the development build. To do so in the Unity engine, go to your Build Settings, or Build Profiles in newer Unity versions, and uncheck the Development Build checkbox. Development builds include debug features that can significantly impact performance. 

27- Review Warnings in the Game Engine and App Store

Fixing errors is a must obviously, otherwise your game won’t run, or may crash. But, do not ignore the warnings in the game engine you’re using. In the Unity engine, when you open a scene or run the game you may see a bunch of warnings in the console window. You should address them because they often point to underlying issues. Watch out for warnings about missing assets. Sometimes, you might assign a script to a GameObject, then you realize you don’t need the script anymore so you delete it. The issue is that your GameObject is still referencing the deleted script, and if it or another object tries to interact with the empty script component in code, your game will likely crash. 

App stores may also give you warnings after uploading a build. You should address them as well as it could make the review process smoother once you send the build for review. 

28- Understand App Store Optimization 

App Store Optimization (ASO) is the process of improving the visibility and ranking of your game in app stores. This is done by carefully choosing the keywords you use in your game’s name and descriptions. The secret ingredient to improving ASO is to find the right keywords, which is easier said than done. It involves lots of research, practice and ideally the usage of keyword research software. Unfortunately, most of these software are not free. You can still use whatever free tools you can find even though they are mostly very limited. 

Once you have a list of keywords, use them in your game’s name, short description and long description. Keep in mind that this process is iterative. If you notice that your keywords are not producing the desired results, you can always find new ones and update your game’s name and descriptions. 

29- Leave the Game Name for Last

As illustrated by the previous point, ASO plays a crucial role in choosing your game’s name. It’s better to decide on a name last and focus on completing the game. Then you will have a better idea of what to name your game and you will have time for ASO. Take your time and do your research before committing to a name, otherwise, months of hard work could amount to very little if your ASO isn’t optimized properly.

30- Use Large Text in Your Store Listing Screenshots

App stores require you to upload screenshots of your game to showcase it to users. If you intend to include text in your screenshots, make sure it’s large enough to be easily readable on mobile devices. Keep in mind that when people are browsing the app stores on their phone, your screenshots will appear small, so you need large text to make it stand out. Always double-check how your screenshots look on a mobile device. 

Conclusion

When developing your mobile game for the first time, you will probably make mistakes and eventually learn from them. We hope that this blog will help you avoid some of them.

We Need Your Help!

Please check out our apps and games, we also have a few Unity icon packs in the Unity Asset Store if you need them for your game. Your support is very much appreciated!