Unity Game Engine Series Part 16: Production & Industry Practices

1. Version Control

Version control is non-negotiable for any project beyond a weekend prototype. It provides history (undo any mistake), collaboration (multiple people working simultaneously), and backup (your work survives hardware failure). For Unity projects, Git with LFS is the most common choice, though Plastic SCM (now Unity Version Control) is gaining traction.

1.1 Git + Unity Setup

# Essential .gitignore for Unity projects
# Generated by Unity
/[Ll]ibrary/
/[Tt]emp/
/[Oo]bj/
/[Bb]uild/
/[Bb]uilds/
/[Ll]ogs/
/[Uu]ser[Ss]ettings/

# MemoryCaptures
/[Mm]emoryCaptures/

# Recordings
/[Rr]ecordings/

# Builds
*.apk
*.aab
*.unitypackage
*.app

# Crashlytics
crashlytics-build.properties

# IDE files (optional — team decides)
.vs/
.vscode/
*.csproj
*.sln
*.suo
*.user

# OS files
.DS_Store
Thumbs.db

# Git LFS setup — track large binary files
# Install Git LFS first: git lfs install

# Track common Unity binary types
git lfs track "*.psd"
git lfs track "*.png"
git lfs track "*.jpg"
git lfs track "*.tga"
git lfs track "*.tif"
git lfs track "*.exr"
git lfs track "*.fbx"
git lfs track "*.obj"
git lfs track "*.blend"
git lfs track "*.wav"
git lfs track "*.mp3"
git lfs track "*.ogg"
git lfs track "*.aiff"
git lfs track "*.mp4"
git lfs track "*.mov"
git lfs track "*.ttf"
git lfs track "*.otf"
git lfs track "*.cubemap"
git lfs track "*.unitypackage"

# CRITICAL: Force text serialization in Unity
# Edit → Project Settings → Editor → Asset Serialization → Force Text
# This makes .scene, .prefab, .asset files human-readable YAML
# enabling meaningful diffs and (sometimes) mergeable conflicts

1.2 Branch Strategy for Games

# Handling merge conflicts in Unity scenes
# Unity's Smart Merge tool can resolve many YAML conflicts automatically

# Set up Unity's Smart Merge as the merge tool in .gitconfig
# [mergetool "unityyamlmerge"]
#     trustExitCode = false
#     cmd = 'C:/Program Files/Unity/Hub/Editor/2022.3.x/Editor/Data/Tools/UnityYAMLMerge.exe' merge -p "$BASE" "$REMOTE" "$LOCAL" "$MERGED"

# When a scene conflict occurs:
# 1. Try UnityYAMLMerge first (handles most simple conflicts)
# 2. If it fails, use "ours" or "theirs" strategy for scenes
# 3. For complex scene conflicts — communicate with your team
#    to avoid working on the same scene simultaneously

# Best practice: Split large scenes into smaller additive scenes
# Scene_Level01_Terrain.unity    (artist works here)
# Scene_Level01_Gameplay.unity   (designer works here)
# Scene_Level01_Lighting.unity   (lighter works here)
# Load all three additively at runtime

2. Team Workflow

2.1 Agile / Scrum for Game Development

Agile methodologies, particularly Scrum, have become the standard for game development. The core adaptation for games: sprint reviews include playtesting, not just demos.

2.2 Code Review & Pair Programming

// Code review checklist for Unity PRs
// A reviewer should check these items before approving:

// 1. FUNCTIONALITY
// - Does the feature work as described in the task?
// - Are edge cases handled (null checks, empty arrays, division by zero)?
// - Does it work in both Editor and build?

// 2. PERFORMANCE
// - No FindObjectOfType/GetComponent in Update()
// - No allocations in hot paths (no LINQ, no string concat, no new in Update)
// - Physics queries use NonAlloc variants
// - Collections are pre-allocated where possible

// 3. ARCHITECTURE
// - Does it follow our project's architecture patterns?
// - Are dependencies injected or looked up through ServiceLocator?
// - Are events properly subscribed/unsubscribed (OnEnable/OnDisable)?
// - No circular dependencies introduced

// 4. UNITY-SPECIFIC
// - SerializeField for private fields (not public)
// - Null checks use Unity's null (obj == null, not ReferenceEquals)
// - Coroutines have proper cleanup
// - No changes to unrelated scenes/prefabs (accidental serialization)

// 5. CODE QUALITY
// - Meaningful variable/method names
// - Comments explain WHY, not WHAT
// - No magic numbers (use constants or SerializeField)
// - Consistent with project coding standards

3. Asset Pipelines

3.1 Artist-Developer Workflow

The artist-developer handoff is one of the most friction-prone areas in game development. A well-defined asset pipeline eliminates guesswork and prevents broken builds.

3.2 Naming Conventions & Validation

# Asset naming conventions — consistency prevents chaos
# Format: [Type]_[Name]_[Variant]_[Size/Resolution]

# Textures
T_Rock_Diffuse_2K.png        # Texture, Rock, Diffuse map, 2048px
T_Rock_Normal_2K.png         # Texture, Rock, Normal map
T_Character_Hero_Albedo.png  # Character texture

# Materials
M_Rock_Mossy.mat             # Material, Rock, Mossy variant
M_Water_Ocean.mat            # Material, Water

# Meshes
SM_Prop_Chair_01.fbx         # Static Mesh, Prop, Chair, variant 01
SK_Character_Hero.fbx        # Skeletal Mesh, Character

# Animations
A_Character_Hero_Run.anim    # Animation, Character, Hero, Run
A_Character_Hero_Idle.anim   # Animation, Character, Hero, Idle

# Audio
SFX_Weapon_Sword_Swing_01.wav    # Sound Effect
MUS_Level_Forest_Ambient.ogg     # Music
AMB_Wind_Light.wav               # Ambient sound

# Prefabs
PFB_Enemy_Skeleton.prefab        # Prefab
PFB_Prop_Barrel_Explosive.prefab # Prefab

# ScriptableObjects
SO_Weapon_Sword_Iron.asset       # ScriptableObject
SO_Enemy_Skeleton_Config.asset   # ScriptableObject

// Automated asset validation tool (Editor script)
using UnityEditor;
using UnityEngine;

public class AssetValidator : AssetPostprocessor
{
    // Runs automatically when textures are imported
    void OnPreprocessTexture()
    {
        TextureImporter importer = (TextureImporter)assetImporter;

        // Enforce max texture size based on path
        if (assetPath.Contains("/UI/"))
        {
            importer.maxTextureSize = 1024;
            importer.mipmapEnabled = false; // No mipmaps for UI
        }
        else if (assetPath.Contains("/Environment/"))
        {
            importer.maxTextureSize = 2048;
            importer.mipmapEnabled = true;
        }

        // Enforce naming convention
        string fileName = System.IO.Path.GetFileNameWithoutExtension(assetPath);
        if (!fileName.StartsWith("T_"))
        {
            Debug.LogWarning($"[AssetValidator] Texture '{fileName}' " +
                $"does not follow naming convention (should start with T_). " +
                $"Path: {assetPath}");
        }
    }

    // Runs when models are imported
    void OnPreprocessModel()
    {
        ModelImporter importer = (ModelImporter)assetImporter;

        // Force consistent import settings
        importer.globalScale = 1f;
        importer.importBlendShapes = false; // Unless explicitly needed
        importer.isReadable = false;        // Save memory
    }
}

4. Debugging at Scale

4.1 Structured Logging Systems

As projects grow, Debug.Log() becomes insufficient. A structured logging system with log levels, categories, and file output transforms debugging from chaos into a systematic process.

// GameLogger.cs — A structured logging system
using System;
using System.IO;
using UnityEngine;

public enum LogLevel { Verbose, Debug, Info, Warning, Error, Fatal }
public enum LogCategory { General, AI, Combat, UI, Audio, Network, Save }

public static class GameLogger
{
    private static LogLevel minimumLevel = LogLevel.Debug;
    private static StreamWriter fileWriter;
    private static readonly object fileLock = new object();

    public static void Init(LogLevel minLevel = LogLevel.Debug)
    {
        minimumLevel = minLevel;

        // Create log file with timestamp
        string logPath = Path.Combine(
            Application.persistentDataPath,
            $"game_log_{DateTime.Now:yyyy-MM-dd_HH-mm-ss}.txt");

        fileWriter = new StreamWriter(logPath, append: true)
        {
            AutoFlush = true
        };

        Info(LogCategory.General,
            $"=== Game Session Started === Build: {Application.version}");
    }

    public static void Verbose(LogCategory cat, string msg)
        => Log(LogLevel.Verbose, cat, msg);
    public static void Debug(LogCategory cat, string msg)
        => Log(LogLevel.Debug, cat, msg);
    public static void Info(LogCategory cat, string msg)
        => Log(LogLevel.Info, cat, msg);
    public static void Warn(LogCategory cat, string msg)
        => Log(LogLevel.Warning, cat, msg);
    public static void Error(LogCategory cat, string msg)
        => Log(LogLevel.Error, cat, msg);
    public static void Fatal(LogCategory cat, string msg)
        => Log(LogLevel.Fatal, cat, msg);

    private static void Log(LogLevel level, LogCategory cat, string msg)
    {
        if (level < minimumLevel) return;

        string timestamp = DateTime.Now.ToString("HH:mm:ss.fff");
        string frame = Time.frameCount.ToString();
        string formatted = $"[{timestamp}][F{frame}][{level}][{cat}] {msg}";

        // Write to Unity Console with appropriate level
        switch (level)
        {
            case LogLevel.Warning:
                UnityEngine.Debug.LogWarning(formatted);
                break;
            case LogLevel.Error:
            case LogLevel.Fatal:
                UnityEngine.Debug.LogError(formatted);
                break;
            default:
                UnityEngine.Debug.Log(formatted);
                break;
        }

        // Write to file
        lock (fileLock)
        {
            fileWriter?.WriteLine(formatted);
        }
    }

    public static void Shutdown()
    {
        Info(LogCategory.General, "=== Game Session Ended ===");
        fileWriter?.Close();
    }
}

// Usage throughout the codebase:
// GameLogger.Info(LogCategory.Combat, $"Player dealt {damage} to {enemy.name}");
// GameLogger.Warn(LogCategory.AI, $"NavMesh path failed for {agent.name}");
// GameLogger.Error(LogCategory.Save, $"Failed to write save file: {ex.Message}");

4.2 Crash Handling & Remote Debugging

// Custom crash reporter
using UnityEngine;

public class CrashReporter : MonoBehaviour
{
    private void Awake()
    {
        // Survive scene loads
        DontDestroyOnLoad(gameObject);

        // Subscribe to unhandled exceptions
        Application.logMessageReceived += HandleLog;
    }

    private void HandleLog(string condition, string stackTrace,
        LogType type)
    {
        if (type == LogType.Exception || type == LogType.Error)
        {
            // Capture crash context
            var crashData = new CrashData
            {
                Message = condition,
                StackTrace = stackTrace,
                Timestamp = System.DateTime.UtcNow,
                SceneName = UnityEngine.SceneManagement
                    .SceneManager.GetActiveScene().name,
                DeviceModel = SystemInfo.deviceModel,
                OS = SystemInfo.operatingSystem,
                GPU = SystemInfo.graphicsDeviceName,
                RAM = SystemInfo.systemMemorySize,
                BuildVersion = Application.version,
                FrameCount = Time.frameCount
            };

            // Save locally
            SaveCrashLocally(crashData);

            // Attempt to send to server (if connected)
            // SendCrashToServer(crashData);

            GameLogger.Fatal(LogCategory.General,
                $"CRASH: {condition}\n{stackTrace}");
        }
    }

    private void SaveCrashLocally(CrashData data)
    {
        string json = JsonUtility.ToJson(data, true);
        string path = System.IO.Path.Combine(
            Application.persistentDataPath,
            $"crash_{System.DateTime.Now:yyyyMMdd_HHmmss}.json");
        System.IO.File.WriteAllText(path, json);
    }

    private void OnDestroy()
    {
        Application.logMessageReceived -= HandleLog;
    }

    [System.Serializable]
    private class CrashData
    {
        public string Message;
        public string StackTrace;
        public System.DateTime Timestamp;
        public string SceneName;
        public string DeviceModel;
        public string OS;
        public string GPU;
        public int RAM;
        public string BuildVersion;
        public int FrameCount;
    }
}

5. Production Timeline

5.1 Milestone Definitions

5.2 Live Ops & Post-Launch

// Feature flags for live ops — enable/disable features remotely
using UnityEngine;
using System.Collections.Generic;

[CreateAssetMenu(menuName = "Config/Feature Flags")]
public class FeatureFlags : ScriptableObject
{
    [System.Serializable]
    public class FeatureFlag
    {
        public string key;
        public bool enabled;
        public string description;
    }

    [SerializeField] private List<FeatureFlag> flags
        = new List<FeatureFlag>();

    private Dictionary<string, bool> flagLookup;

    public void Initialize()
    {
        flagLookup = new Dictionary<string, bool>();
        foreach (var flag in flags)
            flagLookup[flag.key] = flag.enabled;
    }

    // Override with remote config values
    public void ApplyRemoteConfig(Dictionary<string, bool> remoteFlags)
    {
        foreach (var kvp in remoteFlags)
        {
            if (flagLookup.ContainsKey(kvp.Key))
                flagLookup[kvp.Key] = kvp.Value;
        }
    }

    public bool IsEnabled(string featureKey)
    {
        return flagLookup.TryGetValue(featureKey, out bool enabled)
            && enabled;
    }
}

// Usage in game code:
// if (featureFlags.IsEnabled("halloween_event"))
//     ShowHalloweenContent();
//
// if (featureFlags.IsEnabled("new_combat_system"))
//     UseCombatV2();
// else
//     UseCombatV1();

Exercises & Self-Assessment

Series Conclusion

You now have production-level knowledge of Unity workflows. Here are the key takeaways from Part 16:

• Version control is non-negotiable — Git + LFS with Force Text serialization is the standard; Plastic SCM is a strong alternative for artist-heavy teams
• Branch strategy (main/develop/feature/release/hotfix) prevents chaos in multi-person projects; split scenes additively to minimize merge conflicts
• Agile/Scrum works for games — 2-week sprints, daily standups, and sprint reviews with playtesting keep teams aligned and responsive
• Asset pipelines with naming conventions, spec compliance, and automated validation prevent "asset anarchy" and broken builds
• Structured logging and crash reporting transform debugging from guesswork into systematic investigation
• Production milestones (prototype → vertical slice → alpha → beta → gold) provide realistic checkpoints; scope management is the #1 survival skill