Unity Mobile Game Dev

A Scene is a single level or screen in your game — a menu, a battle arena, a shop. It's saved as a .unity file. A game is usually many Scenes loaded one at a time (or streamed together for open worlds). Everything you place, move, or script lives inside whichever Scene is currently open.

A GameObject is the base building block of everything in a Scene — a player, an enemy, a light, a UI button, even an empty organizational folder. On its own, a fresh GameObject does absolutely nothing. It has no shape, no image, no behavior. It's just a named container with a position in the world.

A Component is a piece of functionality you attach to a GameObject. This is the part people find confusing at first: Unity doesn't have a "Player" class or an "Enemy" class built in. Instead, you build up behavior by stacking components onto an empty GameObject:

Every one of those is a separate, swappable piece. Want the player to stop being affected by gravity? Remove the Rigidbody. Want an invisible trigger zone? Keep the Collider, remove the SpriteRenderer. This "stack components" approach is called composition, and it's the core idea behind how Unity works — very different from traditional class inheritance.

When you write a C# script and drag it onto a GameObject, it becomes a component exactly like SpriteRenderer or Rigidbody2D. Every script you write in Unity inherits from a base class called MonoBehaviour, which is what lets Unity call your code automatically at the right moments.

You'll see these three method names in almost every script in this course. They're not interchangeable — Unity calls each one at a different, specific moment:

using UnityEngine;

public class LifecycleDemo : MonoBehaviour
{
    void Awake()  { Debug.Log("1. Awake — I exist"); }
    void Start()  { Debug.Log("2. Start — the scene is ready"); }
    void Update() { Debug.Log("3. Update — this repeats every frame"); }
}

Once you've built a GameObject with the right components attached (say, a fully working enemy with a Rigidbody, Collider, sprite, and AI script), you can drag it from the Hierarchy into the Project window to save it as a Prefab. From then on, that Prefab is a template — you can spawn as many copies as you want at runtime with Instantiate(), and editing the original Prefab updates every copy in every Scene that uses it.

Everything in a Unity scene is a GameObject — an empty container. GameObjects do nothing by themselves. You attach Components to give them behavior.

In Unity, scripts are MonoBehaviours — C# classes that attach to GameObjects. Two key lifecycle methods:

using UnityEngine;

public class HelloWorld : MonoBehaviour
{
    // Called ONCE when the GameObject first appears in the scene
    void Start()
    {
        Debug.Log("Scene started!");
    }

    // Called EVERY FRAME (~60 times/sec on mobile)
    void Update()
    {
        // Game logic goes here
    }
}

1. In Project panel → right-click Scripts/ → Create → C# Script → name it HelloWorld.
2. Double-click to open in your IDE. Paste the code above.
3. Drag the script from Project onto a GameObject in the Hierarchy. Hit Play. Check Console.

A Sprite is a 2D image displayed in your game. Unity handles the import, slicing, packing, and rendering.

1. Drag a PNG into your Assets/Art/Sprites/ folder.
2. Select it in Project → in Inspector set Texture Type: Sprite (2D and UI).
3. Set Pixels Per Unit (PPU) — typically 32, 64, or 100. Keep it consistent across all art. PPU determines how many pixels = 1 Unity unit (meter).
4. For spritesheets: set Sprite Mode: Multiple → open Sprite Editor → Slice → Grid By Cell Size → enter your frame size.
5. Drag the sprite into the Scene or onto a GameObject. Unity auto-adds a SpriteRenderer.

Unity's Tilemap system lets you paint levels like pixels on a grid — perfect for top-down survival games.

1. Hierarchy → right-click → 2D Object → Tilemap → Rectangular. This creates a Grid parent with a Tilemap child.
2. Window → 2D → Tile Palette → Create New Palette → name it "World".
3. Drag your tileset sprites into the Tile Palette. Now you can paint tiles onto the scene grid.
4. Create multiple Tilemaps for layering: Ground, Decoration, Walls, Shadows — each as a child of the same Grid.
5. Add a TilemapCollider2D + CompositeCollider2D to the Walls tilemap for efficient collision.

Grid (GameObject)
├── Tilemap: Ground        Order: 0
├── Tilemap: Shadows       Order: 1
├── Tilemap: Objects       Order: 2
└── Tilemap: Walls         Order: 3 + TilemapCollider2D

For a mobile top-down game, your camera needs to follow the player and fit different screen sizes.

using UnityEngine;

public class CameraFollow : MonoBehaviour
{
    public Transform target;        // Drag player here
    public float    smoothSpeed = 8f;
    public Vector3  offset = new Vector3(0, 0, -10);

    void LateUpdate()
    {
        Vector3 desired   = target.position + offset;
        Vector3 smoothed  = Vector3.Lerp(transform.position, desired,
                                          smoothSpeed * Time.deltaTime);
        transform.position = smoothed;
    }
}

In 2D, Unity needs to know what draws in front of what. Sorting Layers give you explicit control.

1. Edit → Project Settings → Tags and Layers → Sorting Layers. Add: Background, Ground, Shadows, Characters, Projectiles, UI.
2. On each SpriteRenderer and Tilemap Renderer, set the correct Sorting Layer.
3. Use Order In Layer for fine-grained control within the same layer (higher = in front).
4. For characters in a top-down game, dynamically set Order in Layer based on Y position: lower Y = in front.

void Update()
{
    // Multiply by -100 so lower Y = higher sort order
    GetComponent<SpriteRenderer>().sortingOrder =
        Mathf.RoundToInt(-transform.position.y * 100);
}

Add a Rigidbody2D component to any object that should be affected by physics (gravity, forces, velocity).

public class PlayerMovement : MonoBehaviour
{
    public float speed = 5f;
    private Rigidbody2D rb;
    private Vector2 moveInput;

    void Awake() => rb = GetComponent<Rigidbody2D>();

    void Update()
    {
        // Keyboard (replaced by touch joystick on mobile)
        moveInput.x = Input.GetAxisRaw("Horizontal");
        moveInput.y = Input.GetAxisRaw("Vertical");
        moveInput.Normalize();
    }

    void FixedUpdate()
    {
        // Always move physics in FixedUpdate
        rb.linearVelocity = moveInput * speed;
    }
}

1. Edit → Project Settings → Tags and Layers → Layers. Add: Player, Enemy, Projectile, Ground, Pickup.
2. Assign layers to GameObjects in the Inspector (top-right dropdown).
3. Edit → Project Settings → Physics 2D → Layer Collision Matrix. Uncheck pairs that shouldn't collide (e.g. Enemy-Enemy, Projectile-Projectile).

1. Select sliced sprite frames in Project → drag them all into the Scene. Unity auto-creates an Animation clip and a basic Animator.
2. Open Window → Animation → Animation to see the timeline. Adjust Sample Rate (12 fps for pixel art, 24 for smooth).
3. Open Window → Animation → Animator to see the state machine. This controls which animation plays when.
4. Add Parameters (float Speed, bool IsAttacking, trigger Hit) to drive transitions between states.

private Animator anim;
private Rigidbody2D rb;

void Awake() {
    anim = GetComponent<Animator>();
    rb   = GetComponent<Rigidbody2D>();
}

void Update() {
    // Speed param drives Idle ↔ Walk blend
    anim.SetFloat("Speed", rb.linearVelocity.magnitude);

    // Trigger one-shot attack animation
    if (Input.GetKeyDown(KeyCode.Space))
        anim.SetTrigger("Attack");
}

For top-down movement, use a 2D Blend Tree to blend idle/walk animations based on movement direction.

1. In Animator, right-click → Create State → From New Blend Tree.
2. Double-click the Blend Tree → set Blend Type: 2D Simple Directional.
3. Parameters: MoveX (float) and MoveY (float).
4. Add Motion fields for each direction: walk_up (0,1), walk_down (0,-1), walk_right (1,0), walk_left (-1,0). Add diagonals for 8-way.
5. In script: anim.SetFloat("MoveX", moveInput.x) and anim.SetFloat("MoveY", moveInput.y).

Materials define how a surface looks — color, texture, shininess, transparency.

1. Project → right-click → Create → Material. Name it PlayerMat.
2. In Inspector, Shader dropdown → Universal Render Pipeline/Lit for realistic, or URP/Unlit for flat (great for 2.5D characters).
3. Drag your character texture into the Base Map slot.
4. Drag the material onto your mesh in the Scene or Inspector.

2.5D means characters and objects are 3D meshes rendered on a constrained plane — players can't move into/out of the screen. The camera is locked at an angle. The result feels dimensional but plays like a top-down 2D game.

1. Create a Camera. Set Projection: Perspective, Field of View: 50.
2. Rotate the camera: X = 45°, Y = 45° for isometric. Or X = 60°, Y = 0° for a top-down tilted view like LDOE.
3. Position camera above and behind the player — experiment with Z = -10, Y = 8.
4. Attach a camera follow script that locks to player XZ position (never Y — no vertical movement).

public class IsoCamera : MonoBehaviour
{
    public Transform target;
    public Vector3   offset = new Vector3(0, 10, -7);
    public float    smooth = 6f;

    void LateUpdate()
    {
        Vector3 goal = target.position + offset;
        transform.position = Vector3.Lerp(
            transform.position, goal, smooth * Time.deltaTime);
        transform.LookAt(target);
    }
}

1. Import your character .fbx from Blender (or use a Unity asset). Set Rig: Humanoid for mecanim animations.
2. Place the character at Y = 0 (ground plane). Set Rigidbody → Freeze Rotation XYZ and Freeze Position Y.
3. Add a CapsuleCollider for physics. Size it to match the character.
4. Movement is always on the XZ plane (no Y movement unless jumping).
5. Rotate the character to face movement direction using Quaternion.LookRotation.

public class Player25D : MonoBehaviour
{
    public float speed       = 4f;
    public float rotSpeed    = 15f;
    private Rigidbody rb;
    private Animator  anim;

    void Awake() {
        rb   = GetComponent<Rigidbody>();
        anim = GetComponent<Animator>();
    }

    void FixedUpdate()
    {
        float h = Input.GetAxisRaw("Horizontal");
        float v = Input.GetAxisRaw("Vertical");
        Vector3 move = new Vector3(h, 0, v).normalized;

        // Move on XZ plane only
        rb.MovePosition(rb.position + move * speed * Time.fixedDeltaTime);

        // Rotate to face movement direction
        if (move != Vector3.zero)
        {
            Quaternion targetRot = Quaternion.LookRotation(move, Vector3.up);
            rb.MoveRotation(Quaternion.Slerp(
                rb.rotation, targetRot, rotSpeed * Time.fixedDeltaTime));
        }

        // Drive animations
        anim.SetFloat("Speed", move.magnitude);
    }
}

In 2.5D, objects closer to the camera (lower Z in isometric) should draw in front. Unity handles this automatically with the renderer's depth buffer — but for transparent objects (trees, UI) you need manual sorting.

1. For opaque 3D objects: Unity's depth buffer handles sorting automatically. No extra work needed.
2. For transparent sprites (foliage, shadows, UI markers): Use the Sorting Group component + set Order based on world Z position.
3. For ground decals and shadows: use a flat quad with an Unlit transparent material, slightly above Y=0 to avoid Z-fighting.

using UnityEngine.Rendering;

public class DepthSort : MonoBehaviour
{
    private SortingGroup sg;

    void Awake() => sg = GetComponent<SortingGroup>();

    void Update()
    {
        // Objects farther from camera (higher Z) get lower order
        sg.sortingOrder = 5000 - Mathf.RoundToInt(transform.position.z * 10);
    }
}

In a survival game like Death Road, objects should become transparent when the player walks behind them.

public class OcclusionFader : MonoBehaviour
{
    public float  fadeAlpha   = 0.3f;
    public float  fadeSpeed   = 8f;
    private Renderer   rend;
    private float  targetAlpha = 1f;

    void Awake() => rend = GetComponent<Renderer>();

    // Call this from a trigger on the building
    public void SetFaded(bool faded) =>
        targetAlpha = faded ? fadeAlpha : 1f;

    void Update()
    {
        Color c = rend.material.color;
        c.a = Mathf.Lerp(c.a, targetAlpha, fadeSpeed * Time.deltaTime);
        rend.material.color = c;
    }
}

1. Package Manager → search "Input System" → Install. When prompted, switch to the New Input System.
2. Create → Input Actions asset. Add an Action Map "Player" with actions: Move (Vector2), Attack (Button), Interact (Button).
3. For Move, add bindings: WASD keyboard + Left Stick gamepad + a virtual joystick touch binding.
4. Generate C# class: check "Generate C# Class" in the asset Inspector → Apply.

public class PlayerInput : MonoBehaviour
{
    private PlayerControls controls; // generated class
    private Vector2 moveInput;

    void Awake() {
        controls = new PlayerControls();
        controls.Player.Move.performed += ctx =>
            moveInput = ctx.ReadValue<Vector2>();
        controls.Player.Move.canceled  += _ =>
            moveInput = Vector2.zero;
        controls.Player.Attack.performed += _ =>
            DoAttack();
    }
    void OnEnable()  => controls.Enable();
    void OnDisable() => controls.Disable();
}

using UnityEngine;
using UnityEngine.EventSystems;

public class VirtualJoystick : MonoBehaviour,
    IPointerDownHandler, IDragHandler, IPointerUpHandler
{
    public RectTransform handle;
    public float maxRadius = 80f;
    public static Vector2 Input;

    private Vector2 center;

    public void OnPointerDown(PointerEventData e) {
        center = e.position;
    }
    public void OnDrag(PointerEventData e) {
        Vector2 delta = e.position - center;
        Vector2 clamped = Vector2.ClampMagnitude(delta, maxRadius);
        handle.anchoredPosition = clamped;
        Input = clamped / maxRadius;
    }
    public void OnPointerUp(PointerEventData e) {
        handle.anchoredPosition = Vector2.zero;
        Input = Vector2.zero;
    }
}

Then in your player script, replace Input.GetAxisRaw() with VirtualJoystick.Input.x / VirtualJoystick.Input.y.

1. Hierarchy → UI → Canvas. Set Render Mode: Screen Space — Overlay.
2. Add a Canvas Scaler: UI Scale Mode → Scale With Screen Size. Reference: 1080 × 1920 (portrait) or 1920 × 1080 (landscape). Match: Width or Height.
3. Add a Canvas Group to control alpha/interactability for menu transitions.
4. Use Safe Area anchoring for notch/island devices: anchor UI to the safe area rect at runtime.

public class SafeAreaFitter : MonoBehaviour
{
    void Awake() {
        RectTransform rt   = GetComponent<RectTransform>();
        Rect safe          = Screen.safeArea;
        Vector2 anchorMin  = safe.position / new Vector2(Screen.width, Screen.height);
        Vector2 anchorMax  = (safe.position + safe.size) / new Vector2(Screen.width, Screen.height);
        rt.anchorMin       = anchorMin;
        rt.anchorMax       = anchorMax;
    }
}

1. Install: Package Manager → AI Navigation (for Unity 6) → Install.
2. Select all walkable ground objects → Inspector → Static dropdown → check Navigation Static.
3. Window → AI → Navigation → Bake tab → click Bake. A blue overlay shows the walkable area.
4. Add a NavMeshAgent component to the enemy GameObject. Set Speed, Stopping Distance, and Angular Speed.

using UnityEngine.AI;

public class ZombieAI : MonoBehaviour
{
    public Transform  player;
    public float     detectionRange  = 8f;
    public float     attackRange     = 1.5f;
    public float     attackCooldown  = 1.2f;
    private NavMeshAgent agent;
    private float     lastAttack;

    enum State { Idle, Chase, Attack }
    private State state = State.Idle;

    void Awake() => agent = GetComponent<NavMeshAgent>();

    void Update()
    {
        float dist = Vector3.Distance(transform.position, player.position);

        state = dist < attackRange    ? State.Attack
               : dist < detectionRange ? State.Chase
               :                           State.Idle;

        switch (state) {
            case State.Chase:
                agent.SetDestination(player.position); break;
            case State.Attack:
                agent.ResetPath();
                if (Time.time > lastAttack + attackCooldown)
                { DoAttack(); lastAttack = Time.time; }
                break;
            default:
                agent.ResetPath(); break;
        }
    }

    void DoAttack() => Debug.Log("Zombie attacks!");
}

Distance checks alone make enemies feel like they have x-ray vision. Real detection combines a trigger radius with a line-of-sight check so enemies only "see" what's actually in front of them and not blocked by a wall.

bool CanSeePlayer()
{
    Vector3 dir = player.position - transform.position;
    float angle = Vector3.Angle(transform.forward, dir);
    if (angle > fieldOfView * 0.5f) return false;

    if (Physics.Raycast(transform.position + Vector3.up, dir.normalized,
        out RaycastHit hit, detectionRange, obstacleMask))
    {
        return hit.collider.CompareTag("Player");
    }
    return true;
}

Instead of snapping straight from Idle to Chase the instant a player is detected, a suspicion meter ramps up gradually — the enemy notices something, gets more alert, then commits to a chase. It reads as far more "alive" than a hard trigger.

1. While the player is visible, increase suspicion each frame.
2. While hidden, let it decay back toward zero.
3. Cross a low threshold → Wander toward last known position. Cross a high threshold → Chase.

public class EnemyFSM : MonoBehaviour
{
    enum State { Idle, Wander, Chase, Attack, Flee }
    private State state = State.Idle;

    public float suspicion        = 0f;
    public float suspicionRise    = 25f;
    public float suspicionDecay   = 10f;
    public float chaseThreshold   = 70f;
    public float wanderThreshold  = 20f;
    public float lowHealthFlee    = 0.2f;
    public Health   health;

    void Update()
    {
        suspicion += (CanSeePlayer() ? suspicionRise : -suspicionDecay) * Time.deltaTime;
        suspicion = Mathf.Clamp(suspicion, 0f, 100f);

        if (health.Percent < lowHealthFlee) state = State.Flee;
        else if (suspicion >= chaseThreshold)  state = State.Chase;
        else if (suspicion >= wanderThreshold) state = State.Wander;
        else                                       state = State.Idle;

        RunState();
    }

    void RunState()
    {
        switch (state)
        {
            case State.Idle:   DoIdle();   break;
            case State.Wander: DoWander(); break;
            case State.Chase:  DoChase();  break;
            case State.Attack: DoAttack(); break;
            case State.Flee:   DoFlee();   break;
        }
    }
}

Flee isn't just "reverse the chase vector." Run straight away from the player and enemies get stuck backing into corners. Sample a few points around the enemy, keep the one farthest from the player and reachable on the NavMesh.

void DoFlee()
{
    Vector3 away = (transform.position - player.position).normalized;
    Vector3 fleeTarget = transform.position + away * 6f;

    if (NavMesh.SamplePosition(fleeTarget, out NavMeshHit hit, 6f, NavMesh.AllAreas))
        agent.SetDestination(hit.position);
}

Each unique material + mesh combination the GPU renders is a separate draw call. Mobile GPUs choke well before desktop ones — a scene that runs at 500 draw calls on PC can drop a budget Android phone to single-digit fps. The fix isn't fewer objects; it's fewer unique draws.

1. Mark non-moving scenery (ground, walls, props) as Static in the Inspector → enables Static Batching automatically.
2. For moving objects sharing one material (bullets, small props), Unity applies Dynamic Batching automatically if the mesh is under ~300 vertices.
3. Batching only merges objects that share the same material — two identical meshes with different materials still cost two draw calls.

Combining multiple textures into one shared sheet (an atlas) lets many objects reference the same texture, which is required for batching to actually merge them. This matters most for UI and small props like pickups, particles, and decals.

1. Group sprites that appear together often (UI icons, item pickups) into one atlas using Unity's Sprite Atlas asset.
2. Window → 2D → Sprite Atlas → Create New → drag in your loose sprites.
3. Enable Include in Build and Unity will pack and reference the atlas automatically at runtime.

The Profiler tells you how much time rendering costs; the Frame Debugger shows which individual draw calls make up a frame, in order.

1. Window → Analysis → Frame Debugger → Enable.
2. Step through the list — each entry is one draw call. Look for repeated materials that should have batched but didn't.
3. If two identical materials appear as separate draw calls, check that both use the exact same material asset — even a duplicated instance breaks batching.

Before optimizing anything, measure. Unity's Profiler shows exactly where your frame time is going.

1. Window → Analysis → Profiler (Ctrl+7).
2. Hit Play and watch CPU, GPU, Memory, and Rendering graphs.
3. Click a spike in the timeline to see the call stack. The longest bar is your problem.
4. On a real Android device: connect via USB → Profiler → Target: [your device].

Creating and destroying GameObjects at runtime (bullets, enemies, FX) causes garbage collection spikes. Pool them instead.

using System.Collections.Generic;

public class ObjectPool<T> where T : MonoBehaviour
{
    private Queue<T>  pool = new Queue<T>();
    private T         prefab;

    public ObjectPool(T prefab, int preload) {
        this.prefab = prefab;
        for (int i = 0; i < preload; i++) CreateNew();
    }

    public T Get() {
        T obj = pool.Count > 0 ? pool.Dequeue() : CreateNew();
        obj.gameObject.SetActive(true);
        return obj;
    }

    public void Return(T obj) {
        obj.gameObject.SetActive(false);
        pool.Enqueue(obj);
    }

    private T CreateNew() {
        T obj = Object.Instantiate(prefab);
        obj.gameObject.SetActive(false);
        pool.Enqueue(obj);
        return obj;
    }
}

Object pooling fixes Instantiate/Destroy spikes, but garbage collection also creeps in from allocations you don't notice — LINQ queries, string concatenation, and new inside Update().

1. File → Build Settings → Android → Switch Platform.
2. Player Settings → Other Settings → set Scripting Backend: IL2CPP (faster, smaller, required for 64-bit).
3. Target Architectures: check ARM64 (required by Google Play). ARM7 optional for older devices.
4. Set Minify: Release for both Java and IL2CPP. This shrinks the APK.
5. Build → choose .aab (Android App Bundle) for Google Play, .apk for sideload/testing.

1. Player Settings → Publishing Settings → Keystore Manager → Create New.
2. Fill in alias, password, organization. Save the .keystore file somewhere safe.
3. Unity will sign every build with this key automatically.

1. Build a Release .aab with IL2CPP + ARM64 + minify on.
2. Google Play Console → Create App → upload the .aab to Internal Testing first.
3. Required: Privacy Policy URL, Content Rating questionnaire, Target Audience & Content form.
4. Add screenshots: phone (minimum 2), feature graphic (1024×500).
5. Move from Internal → Closed → Open testing → Production over several days.

A vertical slice is a small, complete loop — not a big level, not more content, just every system from this course touching each other in one playable minute. It's the difference between "I finished the modules" and "I can put pieces together into something that runs on a phone."

1. Scene: One 2.5D area (Module 8) — a small enclosed space with the isometric camera locked to the player.
2. Player: The 2.5D character controller (Module 8) with virtual joystick input (Module 9) and an attack button.
3. Enemy: One NavMesh-baked enemy (Module 11) running the full state machine — Idle → Wander → Chase → Attack → Flee (Module 12) — not just a chase script.
4. Effects: Attack swing or bullet VFX drawn from an object pool (Module 14) — no Instantiate/Destroy in the play loop.
5. UI: A health bar HUD (Module 10) that updates when the player takes damage.
6. Performance: Static-batch the environment (Module 13), confirm draw calls stay inside the mid-range budget (~150–300) using the Frame Debugger.
7. Build: A signed, Release-mode .apk with IL2CPP + ARM64 (Module 15) that installs and runs on a real Android device.