How to create a shooter on Android in Unity: a complete guide from idea to publication

Creating a shooter for Android on the engine Unity is a fascinating process that may seem difficult to beginners, but with the right approach it becomes accessible even to novice developers. Mobile shooters remain one of the most popular genres in Google Playand Unity provides all the necessary tools for implementing dynamic gameplay, physics and visual effects. In this article we will look at the entire path - from installing the engine to optimizing the game for weaker devices and publishing it in the store.

It is important to understand that a successful shooter for Android requires not only technical implementation, but also thoughtful level design, balance of complexity and convenient controls. We will look at key aspects: setting up the project for mobile devices, working with assets, programming shooting and movement mechanics, as well as testing on real devices. If you have never worked with Unity, do not worry - the article contains step-by-step guide with explanations for each stage.

We will pay special attention to optimization, since mobile devices have limited resources compared to PCs. You will learn how to reduce the load on the processor, configure the graphics correctly, and avoid common mistakes that lead to low FPS or overheating of the smartphone. At the end of the article - tips on monetization and promotion of the game so that your shooter not only works, but also generates income.

1. Preparing the working environment: installing Unity and the necessary tools

Before you start creating a game, you need to set up the working environment. Let's start with installation Unity Hub —an official project manager that simplifies working with different versions of the engine. Download it from official website and install following the instructions. After installing:

• 📥 Download the latest stable version Unity (recommended 2022 LTS or later).
• 📱 Install the module Android Build Support via Unity Hub (including OpenJDK, Android SDK and NDK).
• 🔧 Check for Java Development Kit (JDK) version 11 or higher.
• 🎮 Install Visual Studio Code or Rider to edit scripts on C#.

After installation, create a new project in Unity Hub, selecting the template 3D Core. Name the project (for example, MobileShooter2026) and specify the folder to save. Important: the first time. startup Unity will ask you to log in - use your account Unity ID (free plan Personal suitable for beginners).

⚠️ Attention: If you work on macOS, make sure you have it installed Xcode (for assembly under iOS, if you plan multiplatform). For Android you will also need to set up environment variables JAVA_HOME and ANDROID_HOME.

Before starting development, check the project settings:

1. Go to Edit → Project Settings → Player.
2. In section Other Settings install Scripting Backend on IL2CPP (optimal for Android).
3. In Identification specify Package Name in format com.yourname.gamename.
4. In Resolution and Presentation select orientation Portrait or Landscape (for shooters usually Landscape).

2. Game design: choice of mechanics and prototyping

Before writing code, decide on main mechanics your shooter. Mobile games are divided into several types:

• 🎯 Top-Down Shooter (top view, example: Hotline Miami).
• 👁️ First-Person Shooter (FPS) (first person, example: Modern Combat).
• 🎮 Dual-Stick Shooter (joystick control, example: Dead Trigger 2).
• 🚀 Bullet Hell (mass attacks of enemies, example: Danmaku Unlimited).

For the first project, we recommend choosing Top-Down Shooter or Dual-Stick Shooter —they are easier to implement and are well suited for touch controls. Create a prototype of the level on paper or in a graphic editor (for example, Aseprite or Photoshop), noting:

• Location of the player and enemies.
• Coverage areas and obstacles.
• Enemy spawn points (spawn points).
• NPC movement trajectories.

B Unity Start by creating a simple scene:

1. Add Plane (floor) and scale it to the size of the level.
2. Create Cube as a temporary player and assign a tag to it Player.
3. Add several Capsule or Sphere as tagged enemies Enemy.

3. Programming basic mechanics: movement, shooting and collisions

Now let's move on to the code. The main scripts that will be needed for the shooter:

Consider an example code for player movement with touch controls (suitable for Dual-Stick Shooter):

using UnityEngine;
using UnityEngine.EventSystems;

public class PlayerMovement : MonoBehaviour
{
[SerializeField] private float moveSpeed = 5f;
[SerializeField] private Joystick joystick;

private Rigidbody rb;

void Start()
{
rb = GetComponent<Rigidbody>();
}

void FixedUpdate()
{
Vector3 moveDirection = new Vector3(joystick.Horizontal, 0, joystick.Vertical);
rb.velocity = moveDirection * moveSpeed;
}
}

For shooting, use Raycast (ray physics) or Instantiate (creating bullets as objects). Example of firing with a delay:

using UnityEngine;

public class PlayerShooting : MonoBehaviour
{
[SerializeField] private GameObject bulletPrefab;
[SerializeField] private Transform firePoint;
[SerializeField] private float fireRate = 0.5f;

private float nextFireTime = 0f;

void Update()
{
if (Input.GetButton("Fire1") && Time.time >= nextFireTime)
{
Shoot();
nextFireTime = Time.time + fireRate;
}
}

void Shoot()
{
Instantiate(bulletPrefab, firePoint.position, firePoint.rotation);
}
}

⚠️ Attention: When using Instantiate for bullets, be sure to configure Object Pooling to optimize. Creating and destroying objects in real time leads to lags on weak devices.

To handle collisions (for example, when a bullet hits an enemy), use the method OnCollisionEnter:

void OnCollisionEnter(Collision collision)
{
if (collision.gameObject.CompareTag("Enemy"))
{
Destroy(collision.gameObject); // Destroy the enemy
Destroy(gameObject); data-i="138">Player movement across the screen|Firing with a delay|Collision of bullets with enemies|Destroying objects when hit-->
}
}

Player movement across the screen|Firing with a delay|Collision of bullets with enemies|Destruction of objects when hit-->

4. Optimization for Android: reducing load and increasing FPS

Mobile devices have limited resources, so optimization is a critical stage:

• 🖼️ Use texture atlases (Sprite Atlas) to reduce the number of draw calls.
• 🎨 Set Texture Compression to ASTC (optimal for Android).
• 🔄 Disable Real-time Shadows and use baked shadows (Baked Lighting).
• 📉 Reduce the number of polygons in 3D models (goal: no more than 500-1000 polygons per object).

Graphics quality settings in Unity:

1. Go to Edit → Project Settings → Quality.
2. Create a new quality level for Android (for example, MobileLow).
3. Disable Anti Aliasing, reduce Shadow Distance to 10-15.
4. Install VSync Count on Don’t Sync (for maximum FPS).

Critical for performance: disable unnecessary components in Player Settings → Splits Application Binary (reduces APK size) and install Target Architecture on ARM64 (most modern Android devices).

To optimize physics:

• Use Fixed Timestep in Time Manager (optimally: 0.02).
• Disable Gravity for objects that do not need physics (for example, decorations).
• Replace OnCollisionEnter with OnTriggerEnter where physical reaction is not needed.

5. Control and interface: adaptation to touch input

Control in mobile shooters should be intuitive. To do this, use:

• 🎮 Virtual joystick (for example, Joystick Pack from Asset Store).
• 👆 Action buttons (jump, reload, change weapons).
• 🔍 Auto-aim (makes shooting easier on small screens).
• 📱 Gestures (for example, swipe to dodge).

To create a joystick:

1. Import a free package Joystick Pack from Asset Store.
2. Add a prefab Fixed Joystick to the scene.
3. Configure script PlayerMovement.cs for working with a joystick (code example is given above).

The interface (UI) must be adaptive. Use Canvas Scaler with settings:

• UI Scale Mode: Scale With Screen Size.
• Reference Resolution: 1920x1080 (standard for Full HD).
• Screen Match Mode: Match Width Or Height (value 0.5).

Example of creating a shooting button:

1. Create Button in Hierarchy (right mouse button → UI → Button).
2. Assign a script with a method to it Shoot().
3. Place the button in the lower right corner (typical location for shooters).

⚠️ Attention: Test controls on real devices, not just editor. Emulators (for example BlueStacks) do not always accurately convey touch input.

6. Testing and debugging on real devices

Testing on a Androiddevice - mandatory step. To do this:

1. Connect your smartphone to the PC via USB and turn on Developer mode (Settings → About phone → Build number - press 7 times).
2. Enable USB debugging in the developer settings.
3. In Unity go to File → Build Settings, select Android and click Build And Run.

Checklist for testing:

FPS stability (at least 30)|Correct operation of controls|No crashes during long-term play|Correct display of UI at different resolutions-->

Common errors and their solutions:

To collect error logs, use Android Logcat (built into Unity when the device is connected) or ADB:

adb logcat -s Unity

7. Build and publish on Google Play

When the game is ready, start assembling .apk or .aab (recommended format for Google Play):

1. Go to File → Build Settings.
2. Select Android and click Player Settings.
3. Install Bundle Version Code and Bundle Version Name (for example, 1.0).
4. Enable Split Application Binary to reduce file size.
5. Click Build and save the file to a folder.

For publication in Google Play Console:

• 📝 Register as a developer (one-time payment $25).
• 📦 Upload .aab-file to section Production.
• 🖼️ Add screenshots (requirements: 1920×1080, without UI elements).
• 🎥 Upload a promotional video (optional, but increases conversion).
• 📋 Fill in the description, keywords and category (for example, Action).

⚠️ Attention: Before publishing, check compliance Google Play rules (for example, the presence of a privacy policy if the game collects data).

After publication, monitor reviews and metrics in Google Play Console. Use Firebase Analytics to track player activity and optimize monetization.

8. Monetization and promotion of the game

There are several ways to monetize a mobile shooter:

• 💰 Advertising (through Unity Ads, AdMob or AppLovin).
• 🛒 In-app purchases (skins, weapons, bonuses).
• 🎖️ Premium version (payment per download).
• 🎁 Battle pass (monthly subscription with rewards).

To integrate advertising:

1. Import the package Unity Monetization from Asset Store.
2. Configure the placement of banners and interstitial advertising in the pause menu.
3. Use rewarded ads (rewarded ads) for bonuses (such as extra lives).

Example code for showing interstitial ads:

using UnityEngine;
using UnityEngine.Advertisements;

public class AdManager : MonoBehaviour, IUnityAdsLoadListener, IUnityAdsShowListener
{
[SerializeField] private string androidAdUnitId = "your_id_here";

void Start()
{
Advertisement.Load(androidAdUnitId, this);
}

public void ShowAd()
{
Advertisement.Show(androidAdUnitId, this);
}

// Implement the IUnityAdsLoadListener and IUnityAdsShowListener
}

To promote the game:

• 📢 Launch targeted advertising in Facebook Ads or Google Ads.
• 🤝 Collaborate with bloggers (send them promotional codes for premium content).
• 🌍 Publish the gameplay on YouTube i TikTok with hashtags #indiegame, #mobilegaming.
• 📊 Optimize ASO (title, description, keywords) for better visibility in Google Play.

FAQ: Frequently asked questions about creating a shooter on Android in Unity

PhotonNetwork.ConnectUsingSettings();
PhotonNetwork.JoinRandomRoom();