<!-- Assets/link.xml -->
<linker>
    <assembly fullname="MyGame.Runtime" preserve="all" />
    <assembly fullname="UnityEngine" preserve="nothing">
        <type fullname="UnityEngine.JsonUtility" preserve="all" />
    </assembly>
</linker>

#if UNITY_EDITOR
using UnityEditor;

public static class DefineSymbols
{
    public static void AddDefine(string define)
    {
        var target = EditorUserBuildSettings.selectedBuildTargetGroup;
        string defines = PlayerSettings.GetScriptingDefineSymbolsForGroup(target);

        if (!defines.Contains(define))
        {
            defines += $";{define}";
            PlayerSettings.SetScriptingDefineSymbolsForGroup(target, defines);
        }
    }
}
#endif

#if DEMO_BUILD
    // Limit content for demo
    maxLevel = 3;
#endif

#if ENABLE_CHEAT_CONSOLE
    debugConsole.SetActive(true);
#endif

#if UNITY_EDITOR
using UnityEditor;
using UnityEditor.AddressableAssets.Settings;
using UnityEditor.AddressableAssets;

public static class AddressableBuildScript
{
    [MenuItem("Build/Build Addressables")]
    public static void BuildAddressables()
    {
        AddressableAssetSettings.BuildPlayerContent();
    }

    [MenuItem("Build/Clean Addressables")]
    public static void CleanAddressables()
    {
        AddressableAssetSettings.CleanPlayerContent();
    }
}
#endif

using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;

public class ContentLoader : MonoBehaviour
{
    public async void LoadLevel(string levelKey)
    {
        var handle = Addressables.LoadSceneAsync(levelKey);
        await handle.Task;

        if (handle.Status == AsyncOperationStatus.Succeeded)
            Debug.Log($"Level '{levelKey}' loaded.");
        else
            Debug.LogError($"Failed to load level '{levelKey}'.");
    }

    public async void DownloadDependencies(string label)
    {
        var sizeHandle = Addressables.GetDownloadSizeAsync(label);
        await sizeHandle.Task;

        long size = sizeHandle.Result;
        Debug.Log($"Download size for '{label}': {size / 1024f / 1024f:F2} MB");

        if (size > 0)
        {
            var downloadHandle = Addressables.DownloadDependenciesAsync(label);
            while (!downloadHandle.IsDone)
            {
                float progress = downloadHandle.PercentComplete;
                Debug.Log($"Downloading: {progress * 100f:F0}%");
                await System.Threading.Tasks.Task.Yield();
            }
            Addressables.Release(downloadHandle);
        }
        Addressables.Release(sizeHandle);
    }
}

#if UNITY_EDITOR
using UnityEditor;
using UnityEditor.Build.Reporting;
using UnityEngine;

public static class BuildScript
{
    private static readonly string[] Scenes =
    {
        "Assets/Scenes/Bootstrap.unity",
        "Assets/Scenes/MainMenu.unity",
        "Assets/Scenes/Game.unity"
    };

    [MenuItem("Build/Build Windows")]
    public static void BuildWindows()
    {
        Build(BuildTarget.StandaloneWindows64, "Builds/Windows/MyGame.exe");
    }

    [MenuItem("Build/Build macOS")]
    public static void BuildMacOS()
    {
        Build(BuildTarget.StandaloneOSX, "Builds/macOS/MyGame.app");
    }

    [MenuItem("Build/Build WebGL")]
    public static void BuildWebGL()
    {
        Build(BuildTarget.WebGL, "Builds/WebGL");
    }

    [MenuItem("Build/Build Android")]
    public static void BuildAndroid()
    {
        // Set Android-specific settings
        PlayerSettings.Android.bundleVersionCode++;
        EditorUserBuildSettings.buildAppBundle = true; // AAB for Google Play
        Build(BuildTarget.Android, "Builds/Android/MyGame.aab");
    }

    [MenuItem("Build/Build iOS")]
    public static void BuildIOS()
    {
        Build(BuildTarget.iOS, "Builds/iOS");
    }

    private static void Build(BuildTarget target, string path)
    {
        var options = new BuildPlayerOptions
        {
            scenes = Scenes,
            locationPathName = path,
            target = target,
            options = BuildOptions.CleanBuildCache
        };

        BuildReport report = BuildPipeline.BuildPlayer(options);
        BuildSummary summary = report.summary;

        if (summary.result == BuildResult.Succeeded)
            Debug.Log($"Build succeeded: {summary.totalSize / 1024f / 1024f:F2} MB in {summary.totalTime.TotalSeconds:F1}s");
        else
            Debug.LogError($"Build failed: {summary.result}");
    }
}
#endif

# .github/workflows/unity-build.yml
name: Unity Build

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  test:
    name: Run Tests
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          lfs: true

      - uses: game-ci/unity-test-runner@v4
        env:
          UNITY_LICENSE: ${{ secrets.UNITY_LICENSE }}
        with:
          projectPath: .
          testMode: all
          artifactsPath: test-results

      - uses: actions/upload-artifact@v4
        if: always()
        with:
          name: test-results
          path: test-results

  build:
    name: Build for ${{ matrix.targetPlatform }}
    needs: test
    runs-on: ubuntu-latest
    strategy:
      matrix:
        targetPlatform:
          - StandaloneWindows64
          - StandaloneOSX
          - StandaloneLinux64
          - WebGL

    steps:
      - uses: actions/checkout@v4
        with:
          lfs: true

      - uses: game-ci/unity-builder@v4
        env:
          UNITY_LICENSE: ${{ secrets.UNITY_LICENSE }}
        with:
          projectPath: .
          targetPlatform: ${{ matrix.targetPlatform }}
          buildName: MyGame
          versioning: Semantic

      - uses: actions/upload-artifact@v4
        with:
          name: build-${{ matrix.targetPlatform }}
          path: build/${{ matrix.targetPlatform }}

#if UNITY_EDITOR
using UnityEditor;
using UnityEditor.Build;
using UnityEditor.Build.Reporting;
using UnityEngine;

public class AutoVersionIncrement : IPreprocessBuildWithReport
{
    public int callbackOrder => 0;

    public void OnPreprocessBuild(BuildReport report)
    {
        // Auto-increment build number
        string version = PlayerSettings.bundleVersion;
        if (System.Version.TryParse(version, out var v))
        {
            string newVersion = $"{v.Major}.{v.Minor}.{v.Build + 1}";
            PlayerSettings.bundleVersion = newVersion;
            Debug.Log($"Version incremented: {version} → {newVersion}");
        }

        // Set Android version code
        PlayerSettings.Android.bundleVersionCode++;
        // Set iOS build number
        PlayerSettings.iOS.buildNumber = PlayerSettings.Android.bundleVersionCode.ToString();
    }
}
#endif

#if UNITY_EDITOR
using UnityEditor;
using UnityEngine;

public static class BuildSizeAnalysis
{
    [MenuItem("Build/Log Build Report")]
    public static void LogBuildReport()
    {
        // After a build, check the Editor.log for size breakdown
        // or use the Build Report Inspector package
        Debug.Log("Check Editor.log for detailed build report.");
        Debug.Log($"Log path: {System.IO.Path.Combine(Application.persistentDataPath, "..", "Unity", "Editor", "Editor.log")}");
    }
}
#endif

Used Assets and files from the Resources folder, sorted by uncompressed size:
 3.2 MB  Assets/Textures/Environment/ground_albedo.png
 2.8 MB  Assets/Audio/Music/main_theme.ogg
 ...

Build Report:
Textures        45.3 MB   52.1%
Meshes          12.1 MB   13.9%
Audio           10.5 MB   12.1%
Scripts          5.2 MB    6.0%
...

## Release Build Checklist

### Assets
- [ ] Texture compression set per platform (ASTC/BC7/ETC2)
- [ ] Audio compression configured (Vorbis for music, ADPCM for SFX)
- [ ] Unused assets removed or excluded from build
- [ ] Addressable groups built and uploaded to CDN

### Settings
- [ ] Scripting Backend set to IL2CPP
- [ ] Managed Stripping Level set to Medium or High
- [ ] Development Build DISABLED
- [ ] Version number updated
- [ ] Splash screen configured (if required)
- [ ] Player resolution / orientation correct

### Quality
- [ ] All automated tests pass (Edit + Play Mode)
- [ ] No compiler warnings
- [ ] Profiled on target hardware — meets FPS target
- [ ] Memory usage within platform budget
- [ ] No `Debug.Log` calls in release (use [Conditional])

### Platform
- [ ] Android: Keystore configured, AAB signed
- [ ] iOS: Signing certificate valid, minimum iOS set
- [ ] WebGL: Compression configured, server MIME types set
- [ ] Console: TRC/Lotcheck requirements met

### Distribution
- [ ] Build uploaded to store / distribution platform
- [ ] Store listing metadata updated
- [ ] Patch notes written