@aqian0/dsh-unity 0.0.0-stage → 0.1.0

package/skills/manage-sprite-atlas/references/complete-workflow.md

@@ -0,0 +1,61 @@
+# Complete Workflow
+
+```
+User Request
+    ↓
+Step 0: Check for existing scripts with [UNITY-SKILL:SPRITEATLAS] identifier
+    ↓
+    ├─ Found existing scripts?
+    │   ↓ YES
+    │   Ask user: Update existing / Create new / Abort
+    │   ↓
+    │   Handle user choice
+    │
+    └─ NO existing scripts or user chose "Create new"
+        ↓
+        Ask "Built-in data or Addressables?"
+        ↓
+        ├─ Option A: Built-in
+        │   ↓
+        │   Generate 1 script: Prebuild generator (includeInBuild=true)
+        │
+        └─ Option B: Addressables
+            ↓
+            Generate 3 scripts:
+              1. Prebuild: Generate atlases + create Addressables entries (includeInBuild=false)
+              2. Postprocess: Build Addressables bundles
+              3. Runtime: Late-binding loader component
+```
+
+**Step 3: Customize Categorization Rules**
+
+Edit the `OnPreprocessBuild` method to match your project's sprite organization. Choose one or combine multiple strategies:
+
+| Strategy | When to Use | Implementation |
+|----------|-------------|----------------|
+| **Folder-based** | Sprites organized by folder structure | `GenerateAtlasByFolder("Assets/Art/UI", "Assets/Atlases/UI.spriteatlasv2")` |
+| **Naming convention** | Sprites follow naming patterns | `GenerateAtlasByNaming("Assets/Art", "icon_", "Assets/Atlases/Icons.spriteatlasv2")` |
+| **Asset labels** | Sprites tagged with labels |
+| **Scene-based** | Sprites used in specific scenes | Query scene references |
+
+**Step 4: Build Your Project**
+
+Atlases are automatically generated/updated during build. **No manual menu clicks required.** This is why prebuild is the default approach.
+
+**For Built-in Data (Option A):**
+- Atlases are included in build
+- Ready for immediate use at runtime
+
+**For Addressables (Option B) - Additional Required Steps:**
+
+You MUST generate THREE scripts (not just one):
+
+1. **Prebuild script** (IPreprocessBuildWithReport) - Generates atlases and creates Addressables entries automatically
+2. **Build Addressables script** (IPostprocessBuildWithReport) - Builds Addressables content bundles
+3. **Late-binding runtime loader** (MonoBehaviour) - Handles on-demand loading via SpriteAtlasManager
+
+The build process will:
+- Generate atlases (prebuild step)
+- Create addressable entries automatically
+- Build addressables content bundles (postprocess step)
+- At runtime: Late-binding loader automatically loads atlases when sprites are first accessed

package/skills/manage-sprite-atlas/references/custom-packing.md

@@ -0,0 +1,147 @@
+# Custom Sprite Packing with ScriptablePacker
+
+Guide for implementing custom sprite packing algorithms in SpriteAtlas V2.
+
+## Table of Contents
+
+- [Overview](#overview)
+- [Use Cases](#use-cases)
+- [ScriptablePacker API](#scriptablepacker-api)
+  - [Abstract Methods](#abstract-methods)
+  - [PackerData Structure](#packerdata-structure)
+  - [SpriteData Structure](#spritedata-structure)
+  - [SpritePack Output Structure](#spritepack-output-structure)
+  - [TextureData Structure](#texturedata-structure)
+  - [PackTransform Options](#packtransform-options)
+- [Example: Grid-Based Packer](#example-grid-based-packer)
+- [Example: Multi-Page Packer](#example-multi-page-packer)
+- [Example: Size-Optimized Packer](#example-size-optimized-packer)
+- [Assigning Custom Packer to Atlas](#assigning-custom-packer-to-atlas)
+- [Best Practices](#best-practices)
+  - [Performance](#performance)
+  - [Correctness](#correctness)
+  - [Maintainability](#maintainability)
+- [Common Pitfalls](#common-pitfalls)
+- [Debugging Tips](#debugging-tips)
+
+## Overview
+
+`ScriptablePacker` is an abstract base class for creating custom packing algorithms. Extend it to implement specialized packing strategies beyond Unity's default algorithms.
+
+**Namespace:** `UnityEditor.U2D`
+**Location:** `SpriteAtlasAsset.bindings.cs`
+
+## Use Cases
+
+Custom packers are useful for:
+- Non-standard sprite arrangements (circular, grid-based, specific patterns)
+- Multi-page atlas generation with custom page selection
+- Sprite preprocessing and optimization before packing
+- Platform-specific packing strategies
+- Domain-specific packing requirements (UI layouts, sprite sheets)
+
+## ScriptablePacker API
+
+### Abstract Methods
+
+See [resources/scriptablepacker.cs](../resources/scriptablepacker.cs).
+
+### PackerData Structure
+
+Contains all input data for packing:
+
+```csharp
+struct PackerData
+{
+    NativeArray<Color32> colorData;   // Pixel data from source textures
+    NativeArray<SpriteData> spriteData; // Sprite information
+    NativeArray<TextureData> textureData; // Texture dimensions
+    NativeArray<int> indexData;       // Sprite mesh indices
+    NativeArray<Vector2> vertexData;  // Sprite mesh vertices
+}
+```
+
+**Important:** Do NOT dispose these arrays - they're managed externally by Unity.
+
+### SpriteData Structure
+
+Information about each sprite:
+
+See [resources/spritedata.cs](../resources/spritedata.cs).
+
+### SpritePack Output Structure
+
+Set this on each `SpriteData` to specify packing result:
+
+See [resources/spritepack.cs](../resources/spritepack.cs).
+
+### TextureData Structure
+
+Source texture information:
+
+See [resources/texturedata.cs](../resources/texturedata.cs).
+
+### PackTransform Options
+
+Sprite transformations during packing:
+
+See [resources/packtransform.cs](../resources/packtransform.cs).
+
+## Example: Grid-Based Packer
+
+Simple example that arranges sprites in a grid pattern.
+
+See [resources/gridspritepacker.cs](../resources/gridspritepacker.cs).
+
+## Example: Multi-Page Packer
+
+Distributes sprites across multiple atlas pages.
+
+See [resources/multipagepacker.cs](../resources/multipagepacker.cs).
+
+## Example: Size-Optimized Packer
+
+Packs larger sprites first for better space utilization.
+
+See [resources/sizeoptimizedpacker.cs](../resources/sizeoptimizedpacker.cs).
+
+## Assigning Custom Packer to Atlas
+
+Use `SpriteAtlasAsset.SetScriptablePacker()` to assign your custom packer.
+
+See [resources/custompackersetup.cs](../resources/custompackersetup.cs).
+
+## Best Practices
+
+### Performance
+
+1. **Minimize array access**: Cache NativeArray values when accessing multiple times
+2. **Avoid allocations**: Don't create new arrays or collections in hot paths
+3. **Use simple algorithms**: Complex packing algorithms can slow down import times
+
+### Correctness
+
+1. **Don't dispose input arrays**: Unity manages these - don't dispose them
+2. **Validate output bounds**: Ensure sprites fit within atlas dimensions
+3. **Handle edge cases**: Empty sprite lists, oversized sprites, etc.
+4. **Return false on failure**: Let Unity know packing failed
+
+### Maintainability
+
+1. **Make packer configurable**: Add public properties for tweaking behavior
+2. **Add debug logging**: Log packing statistics and warnings
+3. **Document algorithm**: Explain packing strategy in comments
+4. **Test with various inputs**: Different sprite sizes, counts, and arrangements
+
+## Common Pitfalls
+
+1. **Disposing input arrays**: Unity manages these - don't dispose them
+2. **Forgetting to set `sprite.output`**: Each sprite needs output position
+3. **Exceeding atlas bounds**: Validate that packed sprites fit within max texture size
+4. **Not handling multi-page**: Set `sprite.output.page` correctly for multi-page atlases
+5. **Modifying read-only fields**: Some fields like texture dimensions are read-only
+6. **Forgetting to assign packer**: Use `SetScriptablePacker()` before saving atlas
+
+## Debugging Tips
+
+See [resources/packerdebugging.cs](../resources/packerdebugging.cs).

package/skills/manage-sprite-atlas/references/delivery-mechanism.md

@@ -0,0 +1,30 @@
+# 1. Delivery Mechanism (REQUIRED)
+
+Ask: "How do you want to deliver the sprite atlases?"
+
+**Option A: Built-in Data (Immediate Loading)**
+- Atlases are included in the build and loaded immediately
+- Set `includeInBuild = true`
+- **Suitable for**: Core UI, main gameplay sprites, always-needed assets
+- **Pros**: Simple, no additional packages, instant access
+- **Cons**: Increases initial build size, cannot update without new build
+
+**Option B: Late-Binding via Addressables (On-Demand Loading)**
+- Atlases are NOT included in build, loaded on-demand via Addressables
+- Set `includeInBuild = false`
+- Create Addressables entries for each atlas
+- Add addressable setup as prebuild step
+- **🚨 REQUIRED**: Build Addressables content as build step
+- **🚨 REQUIRED**: Create late-binding runtime loader script
+- **Suitable for**: DLC content, optional features, large assets, downloadable content
+- **Pros**: Smaller initial build, can update independently, on-demand loading
+- **Cons**: Requires Addressables package, async loading, network dependency
+
+| Use Case | Recommended |
+|----------|-------------|
+| Core UI sprites that are always visible | **Option A: Built-in** |
+| Tutorial or onboarding sprites | **Option A: Built-in** |
+| Level-specific sprites (100+ levels) | **Option B: Addressables** |
+| DLC or seasonal content | **Option B: Addressables** |
+| Localized UI sprites (multiple languages) | **Option B: Addressables** |
+| Character skins or cosmetics | **Option B: Addressables** |

package/skills/manage-sprite-atlas/references/key-requirements.md

@@ -0,0 +1,21 @@
+# Key Requirements (V2-Specific)
+
+1. **🚨 ALWAYS check for existing scripts FIRST**: Before generating code, scan for scripts with `[UNITY-SKILL:SPRITEATLAS]` identifier and prompt user to update or create new
+2. **🚨 ALWAYS tag generated scripts**: Include skill identifier at the top of every generated script for future detection
+3. **🚨 ALWAYS ask for delivery mechanism**: Ask user "Built-in data or Addressables?" before generating code
+4. **🚨 ALWAYS enable Sprite Packer mode**: Set `EditorSettings.spritePackerMode = SpritePackerMode.SpriteAtlasV2` in prebuild script
+5. **🚨 ALWAYS use prebuild generation**: Implement `IPreprocessBuildWithReport` as the DEFAULT approach for creating atlases
+6. **🚨 ONLY add sprites from Assets/ folder**: Never add sprites from Packages, built-in assets, or external locations
+7. **🚨 For Addressables delivery, ALWAYS generate THREE scripts**:
+   - Prebuild atlas generator with Addressables setup
+   - `IPostprocessBuildWithReport` to build Addressables content
+   - Late-binding runtime loader script (extends `SpriteAtlasManager`)
+8. **Set includeInBuild correctly**: `true` for built-in data, `false` for Addressables
+9. **Two-Step Editor Pattern**: Create with `SpriteAtlasAsset` → Save → Import → Configure via `SpriteAtlasImporter` → SaveAndReimport()
+10. **Never use `SpriteAtlas` in editor code** — except `SpriteAtlas.GetPackables()` instance method on a loaded runtime atlas
+11. **Variants reference master**: Use `SetMasterAtlas(SpriteAtlas)` with runtime instance loaded via `AssetDatabase.LoadAssetAtPath<SpriteAtlas>()`
+12. **Platform format assignment**: Use `format = TextureImporterFormat.ASTC_6x6` directly (no cast)
+13. **File extension**: V2 atlases use `.spriteatlasv2` (not `.spriteatlas`)
+14. **`SpriteAtlasUtility.PackAtlases()` is optional**: Only for editor preview; build-time packing is automatic
+
+For common errors and invalid patterns, see [references/common-errors.md](common-errors.md).

package/skills/manage-sprite-atlas/references/manual-authoring.md

@@ -0,0 +1,39 @@
+# Manual Authoring (Advanced - Not Default)
+
+> ⚠ **WARNING**: Manual authoring is NOT the default approach. Only use these patterns when the user EXPLICITLY requests manual control or editor preview during development.
+
+> 🚨 **DEFAULT APPROACH**: Use prebuild generation with `IPreprocessBuildWithReport` instead. See the main SKILL.md Quick Start section.
+
+## When to Use Manual Authoring
+
+**Manual authoring is appropriate ONLY for:**
+- Hand-optimized sprite layouts where exact positioning matters
+- Custom sprite ordering requirements
+- Editor preview during authoring workflow
+- Explicitly requested by user
+
+**DO NOT use manual authoring when:**
+- User asks to "create sprite atlas" (use prebuild)
+- User asks to "optimize sprites" (use prebuild)
+- User asks for automated workflow (use prebuild)
+- No specific manual control requirement mentioned
+
+## Create and Configure Master Atlas (Manual Pattern)
+
+> 🚨 **REMINDER**: Only use this if explicitly requested. Default is prebuild with `IPreprocessBuildWithReport`.
+
+See [resources/createandconfiguremasteratlas.cs](../resources/createandconfiguremasteratlas.cs).
+
+## Create Variant Atlas (Manual Pattern)
+
+> 🚨 **REMINDER**: Only use this if explicitly requested. Default is prebuild with `IPreprocessBuildWithReport`.
+
+See [resources/variantatlas.cs](../resources/variantatlas.cs).
+
+## Runtime Dynamic Loading
+
+See [resources/runtimeatlasloader.cs](../resources/runtimeatlasloader.cs).
+
+## Runtime Sprite Access
+
+See [resources/runtimespriteaccess.cs](../resources/runtimespriteaccess.cs).

package/skills/manage-sprite-atlas/references/namespaces.md

@@ -0,0 +1,15 @@
+# Namespaces
+
+**Editor Scripts:**
+```csharp
+using UnityEditor;            // AssetImporter, AssetDatabase
+using UnityEditor.U2D;        // SpriteAtlasAsset, SpriteAtlasImporter, SpriteAtlasUtility
+using UnityEngine;            // Runtime types (e.g., TextureImporterFormat)
+using UnityEngine.U2D;        // SpriteAtlas
+```
+
+**Runtime Scripts:**
+```csharp
+using UnityEngine;            // Core Unity types
+using UnityEngine.U2D;        // SpriteAtlas, SpriteAtlasManager
+```

package/skills/manage-sprite-atlas/references/v2-architecture.md

@@ -0,0 +1,21 @@
+# Critical V2 Architecture
+
+| Context | Component | Purpose | Allowed Usage |
+|---------|-----------|---------|---------------|
+| **Editor Authoring** | `SpriteAtlasAsset` | Add/remove sprites/folders; store metadata | ✅ Editor scripts only |
+| **Editor Settings** | `SpriteAtlasImporter` | Configure texture, packing, platform settings | ✅ Editor scripts only |
+| **Editor Packing** | `SpriteAtlasUtility.PackAtlases()` | *Optional* editor preview packing (not for build) | ⚠ Only for preview; atlases auto-pack at build |
+| **Runtime** | `SpriteAtlas` | Query packed sprites (read-only) | ✅ Runtime scripts only |
+| **Runtime Loading** | `SpriteAtlasManager` | Dynamic loading callbacks | ✅ Runtime scripts only |
+
+## Forbidden Cross-Context Usage (Common Error Sources)
+
+| ❌ Invalid Pattern | ✅ Correct Pattern |
+|--------------------|-------------------|
+| `new SpriteAtlas()` in editor code | Use `SpriteAtlasAsset` + `SpriteAtlasImporter` |
+| `AssetDatabase.LoadAssetAtPath<SpriteAtlas>(...)` in editor | Use `SpriteAtlasAsset.Load(...)` |
+| `SpriteAtlasAsset.GetPackables()` in editor | Use `SpriteAtlas.GetPackables()` |
+| Modifying `SpriteAtlas` in editor scripts | Modify `SpriteAtlasAsset` → reimport → use `SpriteAtlasImporter` |
+| Create variants from original packable objects (sprites/folders) | Creating variants from a Master runtime `SpriteAtlas` |
+
+**NEVER script against `SpriteAtlas` in editor code** — it is *only* for runtime use in V2 except for GetPackables.

package/skills/manage-sprite-atlas/resources/authoringvsruntime.cs

@@ -0,0 +1,176 @@
+// [UNITY-SKILL:SPRITEATLAS]
+using UnityEditor;
+using UnityEditor.U2D;
+using UnityEngine;
+using UnityEngine.U2D;
+
+/// <summary>
+/// Explains the critical distinction between editor authoring and runtime access.
+/// SpriteAtlasAsset (editor) vs SpriteAtlas (runtime) - never mix them!
+/// </summary>
+public static class AuthoringVsRuntimeDocumentation
+{
+    /// <summary>
+    /// SPRITEATLASASSET - Editor-Only Type
+    /// Used for creating, modifying, and configuring atlases in the editor.
+    /// Cannot be used at runtime.
+    /// </summary>
+    public static void Use_SpriteAtlasAsset_Editor()
+    {
+        // ✅ CORRECT: Using SpriteAtlasAsset in editor code
+
+        // Create new atlas asset
+        SpriteAtlasAsset asset = new SpriteAtlasAsset();
+
+        // Add sprites for authoring
+        Object[] sprites = AssetDatabase.LoadAllAssetsAtPath("Assets/Sprites/mySprite.png");
+        asset.Add(sprites);
+
+        // Save to disk
+        SpriteAtlasAsset.Save(asset, "Assets/MyAtlas.spriteatlasv2");
+
+        // Configure via importer (editor-only)
+        AssetDatabase.ImportAsset("Assets/MyAtlas.spriteatlasv2");
+        SpriteAtlasImporter importer = AssetImporter.GetAtPath("Assets/MyAtlas.spriteatlasv2") as SpriteAtlasImporter;
+        importer.includeInBuild = true;
+        importer.SaveAndReimport();
+    }
+
+    /// <summary>
+    /// SPRITEATLAS - Runtime-Only Type
+    /// Used for querying packed sprites at runtime.
+    /// Cannot be created or modified in editor code.
+    /// </summary>
+    public static void Use_SpriteAtlas_Runtime()
+    {
+        // ✅ CORRECT: Using SpriteAtlas at runtime
+
+        // Register for late-binding to load atlases on-demand
+        SpriteAtlasManager.atlasRegistered += OnAtlasLoaded;
+    }
+
+    private static void OnAtlasLoaded(SpriteAtlas atlas)
+    {
+        // Query sprites from loaded atlas (runtime only)
+        Object[] packables = atlas.GetPackables();
+        // ... use sprites ...
+    }
+
+    /// <summary>
+    /// ❌ WRONG: Using SpriteAtlas in editor code.
+    /// SpriteAtlas is a runtime type and cannot be constructed in editor.
+    /// </summary>
+    public static void Wrong_UseSpriteAtlasInEditor()
+    {
+        // ❌ WRONG: Cannot construct SpriteAtlas in editor
+        // SpriteAtlas atlas = new SpriteAtlas(); // Compile error!
+
+        // ❌ WRONG: Cannot load SpriteAtlas in editor
+        // SpriteAtlas atlas = AssetDatabase.LoadAssetAtPath<SpriteAtlas>("path"); // Runtime error!
+    }
+
+    /// <summary>
+    /// ❌ WRONG: Using SpriteAtlasAsset at runtime.
+    /// SpriteAtlasAsset is an asset file, not a runtime object.
+    /// </summary>
+    public static void Wrong_UseSpriteAtlasAssetRuntime()
+    {
+        // ❌ WRONG: Cannot use SpriteAtlasAsset in runtime code
+        // SpriteAtlasAsset asset = someReference; // This is an editor type!
+    }
+
+    /// <summary>
+    /// ✅ CORRECT: Two-step V2 pattern for atlas creation.
+    /// Step 1: Create with SpriteAtlasAsset (editor)
+    /// Step 2: Use at runtime via SpriteAtlas
+    /// </summary>
+    public static void Correct_TwoStepPattern()
+    {
+        // ===== STEP 1: EDITOR AUTHORING (SpriteAtlasAsset) =====
+
+        // In editor script or prebuild processor:
+        SpriteAtlasAsset asset = new SpriteAtlasAsset();
+        asset.Add(AssetDatabase.LoadAllAssetsAtPath("Assets/Sprites/mySprite.png"));
+        SpriteAtlasAsset.Save(asset, "Assets/MyAtlas.spriteatlasv2");
+        AssetDatabase.ImportAsset("Assets/MyAtlas.spriteatlasv2");
+
+        // Configure via importer
+        SpriteAtlasImporter importer = AssetImporter.GetAtPath("Assets/MyAtlas.spriteatlasv2") as SpriteAtlasImporter;
+        importer.includeInBuild = true; // Include in build for immediate loading
+        importer.SaveAndReimport();
+
+        // ===== STEP 2: RUNTIME ACCESS (SpriteAtlas) =====
+
+        // In runtime script:
+        /*
+        public class MyRuntimeScript : MonoBehaviour
+        {
+            private void Awake()
+            {
+                // Register for late-binding if using Addressables
+                SpriteAtlasManager.atlasRegistrationNeeded += OnAtlasRegistrationNeeded;
+            }
+
+            private void OnAtlasRegistrationNeeded(Sprite sprite)
+            {
+                // Load atlas via Addressables/AssetBundles
+                // The loaded SpriteAtlas is what you query at runtime
+            }
+        }
+        */
+    }
+
+    /// <summary>
+    /// Summary table of when to use each type:
+    ///
+    /// | Context      | Type              | Purpose                              |
+    /// |--------------|-------------------|--------------------------------------|
+    /// | Editor       | SpriteAtlasAsset  | Create, modify, configure atlases    |
+    /// | Editor       | SpriteAtlasImporter | Set texture, packing, platform settings |
+    /// | Runtime      | SpriteAtlas       | Query packed sprites (read-only)     |
+    /// | Runtime      | SpriteAtlasManager| Dynamic loading callbacks            |
+    /// </summary>
+    public static void Summary_Table()
+    {
+        /*
+        +------------------+-------------------+--------------------------------------+
+        | Context          | Type              | Purpose                              |
+        +------------------+-------------------+--------------------------------------+
+        | Editor           | SpriteAtlasAsset  | Create, modify, configure atlases    |
+        | Editor           | SpriteAtlasImporter | Set texture, packing, platform settings |
+        | Runtime          | SpriteAtlas       | Query packed sprites (read-only)     |
+        | Runtime          | SpriteAtlasManager| Dynamic loading callbacks            |
+        +------------------+-------------------+--------------------------------------+
+        */
+    }
+}
+
+/// <summary>
+/// Example: Editor script that creates an atlas using the correct types.
+/// </summary>
+public static class CorrectEditorScript
+{
+    [MenuItem("Tools/Create Atlas")]
+    public static void CreateAtlas()
+    {
+        // Use SpriteAtlasAsset for editor authoring
+        SpriteAtlasAsset asset = new SpriteAtlasAsset();
+
+        // Add sprites from a folder
+        string[] guids = AssetDatabase.FindAssets("t:Sprite", new[] { "Assets/Sprites" });
+        Object[] sprites = new Object[guids.Length];
+        for (int i = 0; i < guids.Length; i++)
+        {
+            sprites[i] = AssetDatabase.LoadAssetAtPath<Sprite>(
+                AssetDatabase.GUIDToAssetPath(guids[i]));
+        }
+        asset.Add(sprites);
+
+        // Save and import
+        string path = "Assets/Atlases/MyAtlas.spriteatlasv2";
+        SpriteAtlasAsset.Save(asset, path);
+        AssetDatabase.ImportAsset(path);
+
+        Debug.Log($"Created atlas at {path}");
+    }
+}

package/skills/manage-sprite-atlas/resources/buildaddressablespostprocess.cs

@@ -0,0 +1,59 @@
+// [UNITY-SKILL:SPRITEATLAS]
+// [TYPE:POSTPROCESS-ADDRESSABLES]
+// Generated by SpriteAtlas V2 Skill
+// This script builds Addressables content after atlas generation
+
+using UnityEditor;
+using UnityEditor.Build;
+using UnityEditor.Build.Reporting;
+using UnityEngine;
+
+#if UNITY_ADDRESSABLES
+using UnityEditor.AddressableAssets;
+using UnityEditor.AddressableAssets.Settings;
+using UnityEditor.AddressableAssets.Build;
+#endif
+
+/// <summary>
+/// Builds Addressables content after atlas generation
+/// This ensures atlases are available for on-demand loading
+/// </summary>
+public class BuildAddressablesPostprocess : IPostprocessBuildWithReport
+{
+    public int callbackOrder => 1; // Run after atlas generation (callbackOrder 0)
+
+    public void OnPostprocessBuild(BuildReport report)
+    {
+#if UNITY_ADDRESSABLES
+        Debug.Log("[Addressables] Building Addressables content...");
+
+        var settings = AddressableAssetSettingsDefaultObject.Settings;
+        if (settings == null)
+        {
+            Debug.LogError("[Addressables] Addressables settings not found. Cannot build addressables content.");
+            return;
+        }
+
+        try
+        {
+            // Build addressables content
+            AddressableAssetSettings.BuildPlayerContent(out AddressablesPlayerBuildResult result);
+
+            if (!string.IsNullOrEmpty(result.Error))
+            {
+                Debug.LogError($"[Addressables] Build failed: {result.Error}");
+            }
+            else
+            {
+                Debug.Log($"[Addressables] Build completed successfully. Duration: {result.Duration}");
+            }
+        }
+        catch (System.Exception ex)
+        {
+            Debug.LogError($"[Addressables] Build exception: {ex.Message}");
+        }
+#else
+        Debug.LogWarning("[Addressables] Addressables package not installed. Skipping addressables build.");
+#endif
+    }
+}