@musashishao/agent-kit 1.8.2 → 1.9.1

package/.agent/skills/game-development/unity-mobile-optimization/SKILL.md

@@ -0,0 +1,271 @@
+---
+name: unity-mobile-optimization
+description: Mobile-specific optimization for Unity games. Battery, thermal, memory management, build size, and platform-specific optimizations for iOS and Android.
+allowed-tools: Read, Write, Edit, Bash, Grep, WebSearch
+---
+
+# Unity Mobile Optimization Skill
+
+> Expert-level mobile optimization patterns for Unity 6 targeting iOS and Android.
+
+---
+
+## When to Use
+
+- Optimizing Unity games for mobile devices
+- Debugging performance issues on phones/tablets
+- Reducing battery drain and heat
+- Minimizing build size for app stores
+- Platform-specific tuning (iOS Metal, Android Vulkan)
+
+---
+
+## Performance Targets
+
+| Metric | iOS Target | Android Target | Tool |
+|--------|------------|----------------|------|
+| **FPS** | 60 stable | 30-60 stable | Profiler |
+| **Frame Time** | < 16.67ms | < 33ms | Profiler |
+| **Draw Calls** | < 100 | < 80 | Frame Debugger |
+| **SetPass Calls** | < 50 | < 40 | Frame Debugger |
+| **Memory** | < 500MB | < 400MB | Memory Profiler |
+| **Battery** | < 5%/hour | < 8%/hour | Device monitor |
+| **Build Size** | < 200MB | < 150MB AAB | Build Report |
+
+---
+
+## Battery Optimization
+
+### Frame Rate Management
+```csharp
+public class BatteryManager : MonoBehaviour
+{
+    [SerializeField] private int _gameplayFPS = 60;
+    [SerializeField] private int _menuFPS = 30;
+    [SerializeField] private int _backgroundFPS = 5;
+    
+    public void SetGameState(GameState state)
+    {
+        Application.targetFrameRate = state switch
+        {
+            GameState.Playing => _gameplayFPS,
+            GameState.Menu => _menuFPS,
+            GameState.Paused => _backgroundFPS,
+            _ => _gameplayFPS
+        };
+    }
+    
+    void OnApplicationPause(bool paused)
+    {
+        Application.targetFrameRate = paused ? 1 : _gameplayFPS;
+    }
+}
+```
+
+### GPU Throttling Detection
+```csharp
+public class ThermalManager : MonoBehaviour
+{
+    private float _lastFrameTime;
+    private int _consecutiveSlowFrames;
+    
+    void Update()
+    {
+        float frameTime = Time.deltaTime;
+        
+        // Detect thermal throttling
+        if (frameTime > 0.02f) // >20ms
+        {
+            _consecutiveSlowFrames++;
+            if (_consecutiveSlowFrames > 60) // 1 second of slow frames
+            {
+                ReduceQuality();
+                _consecutiveSlowFrames = 0;
+            }
+        }
+        else
+        {
+            _consecutiveSlowFrames = 0;
+        }
+    }
+    
+    void ReduceQuality()
+    {
+        QualitySettings.DecreaseLevel();
+        Application.targetFrameRate = 30;
+    }
+}
+```
+
+---
+
+## Memory Management
+
+### Addressables Best Practices
+```csharp
+public class AssetLoader : MonoBehaviour
+{
+    private Dictionary<string, AsyncOperationHandle> _loadedAssets = new();
+    
+    public async UniTask<T> LoadAsset<T>(string key) where T : Object
+    {
+        if (_loadedAssets.TryGetValue(key, out var handle))
+            return (T)handle.Result;
+        
+        var newHandle = Addressables.LoadAssetAsync<T>(key);
+        await newHandle.ToUniTask();
+        
+        _loadedAssets[key] = newHandle;
+        return newHandle.Result as T;
+    }
+    
+    public void UnloadAsset(string key)
+    {
+        if (_loadedAssets.TryGetValue(key, out var handle))
+        {
+            Addressables.Release(handle);
+            _loadedAssets.Remove(key);
+        }
+    }
+    
+    public void UnloadAll()
+    {
+        foreach (var handle in _loadedAssets.Values)
+            Addressables.Release(handle);
+        _loadedAssets.Clear();
+        
+        Resources.UnloadUnusedAssets();
+        GC.Collect();
+    }
+}
+```
+
+### Texture Compression Guide
+| Platform | Format | Quality | Use Case |
+|----------|--------|---------|----------|
+| iOS | ASTC 6x6 | High | Characters, UI |
+| iOS | ASTC 8x8 | Medium | Backgrounds |
+| Android | ETC2 | Good | Universal |
+| Android | ASTC | Best | High-end only |
+
+---
+
+## Build Size Optimization
+
+### Code Stripping
+```csharp
+// link.xml - Prevent stripping needed assemblies
+<linker>
+    <assembly fullname="UnityEngine">
+        <type fullname="UnityEngine.Networking.*" preserve="all"/>
+    </assembly>
+</linker>
+```
+
+### Build Settings
+```
+Player Settings:
+- Scripting Backend: IL2CPP
+- Managed Stripping Level: High
+- Engine Code Stripping: Enabled
+- Compress Meshes: Enabled
+- Vertex Compression: Everything
+
+Android:
+- Build App Bundle (AAB)
+- Split Application Binary
+- Target Architectures: ARM64 only
+
+iOS:
+- App Thinning: Automatic
+- Strip Engine Code: Enabled
+```
+
+---
+
+## Platform-Specific
+
+### iOS Metal
+```csharp
+// Check Metal support
+if (SystemInfo.graphicsDeviceType == GraphicsDeviceType.Metal)
+{
+    // Metal-specific optimizations
+    QualitySettings.antiAliasing = 0; // Use FXAA instead
+}
+```
+
+### Android Vulkan
+```csharp
+// Prefer Vulkan, fallback to GLES
+// Set in Player Settings: Auto Graphics API
+
+#if UNITY_ANDROID
+void Start()
+{
+    bool isVulkan = SystemInfo.graphicsDeviceType == GraphicsDeviceType.Vulkan;
+    Debug.Log($"Graphics API: {(isVulkan ? "Vulkan" : "OpenGL ES")}");
+}
+#endif
+```
+
+---
+
+## Profiling Workflow
+
+### Step 1: Profile on Device
+```
+1. Build Development Build with Autoconnect Profiler
+2. Connect device via USB/WiFi
+3. Run game and capture frames
+4. Focus on:
+   - GC.Alloc column
+   - Rendering time
+   - Scripts time
+```
+
+### Step 2: Identify Hotspots
+```csharp
+// Use profiler markers
+using (new ProfilerMarker("MyExpensiveFunction").Auto())
+{
+    // Code to profile
+}
+```
+
+### Step 3: Fix Priority
+1. GC Allocations (causes stutters)
+2. Draw calls (GPU bound)
+3. Physics (CPU heavy)
+4. Scripts (logic overhead)
+
+---
+
+## Quick Wins Checklist
+
+- [ ] `Application.targetFrameRate` set explicitly
+- [ ] All `GetComponent` calls cached
+- [ ] Object pooling for bullets/effects
+- [ ] Static batching enabled
+- [ ] Texture compression correct per platform
+- [ ] No `Resources.Load` in gameplay
+- [ ] `CompareTag` instead of `tag ==`
+- [ ] `NonAlloc` physics methods used
+- [ ] StringBuilder for string operations
+- [ ] No LINQ in Update loops
+
+---
+
+## Anti-Patterns
+
+| ❌ Don't | ✅ Do |
+|----------|-------|
+| Max quality everywhere | Adjust by device tier |
+| Ignore battery/heat | Monitor and adapt |
+| 4K textures on mobile | Max 2K, usually 1K |
+| Full mesh colliders | Simple primitives |
+| Sync asset loading | Async with loading screen |
+
+---
+
+> **Remember:** Profile first, optimize second. Don't guess.

package/.agent/skills/game-development/webgpu-shading/SKILL.md

@@ -0,0 +1,209 @@
+---
+name: webgpu-shading
+description: WebGPU and shader programming for web games. Covers WGSL, Three.js WebGPU, Babylon.js, and shader optimization.
+allowed-tools: Read, Write, Edit, Bash, Grep, WebSearch
+---
+
+# WebGPU & Shading Skill
+
+> Next-generation web graphics with WebGPU and WGSL.
+
+## When to Use
+
+- Developing 3D web games with modern graphics
+- Writing custom shaders (WGSL, GLSL)
+- Optimizing rendering performance
+- Using Three.js or Babylon.js with WebGPU
+
+---
+
+## WebGPU Browser Support (2025)
+
+| Browser | Status |
+|---------|--------|
+| Chrome 113+ | ✅ Stable |
+| Edge 113+ | ✅ Stable |
+| Firefox 131+ | ✅ Stable |
+| Safari 18+ | ✅ Stable |
+| **Total Coverage** | ~78% |
+
+---
+
+## WebGPU vs WebGL
+
+| Feature | WebGL | WebGPU |
+|---------|-------|--------|
+| API Style | Immediate | Command-based |
+| Compute Shaders | No | Yes |
+| Multi-threading | Limited | Full |
+| Memory Control | Low | High |
+| Performance | Good | Better |
+
+---
+
+## Basic WebGPU Setup
+
+```javascript
+async function initWebGPU() {
+    if (!navigator.gpu) {
+        throw new Error("WebGPU not supported");
+    }
+    
+    const adapter = await navigator.gpu.requestAdapter();
+    const device = await adapter.requestDevice();
+    
+    const canvas = document.getElementById("canvas");
+    const context = canvas.getContext("webgpu");
+    
+    context.configure({
+        device,
+        format: navigator.gpu.getPreferredCanvasFormat(),
+        alphaMode: "premultiplied"
+    });
+    
+    return { device, context };
+}
+```
+
+---
+
+## WGSL Shader Basics
+
+### Vertex Shader
+
+```wgsl
+struct VertexInput {
+    @location(0) position: vec3f,
+    @location(1) uv: vec2f,
+}
+
+struct VertexOutput {
+    @builtin(position) position: vec4f,
+    @location(0) uv: vec2f,
+}
+
+@group(0) @binding(0) var<uniform> mvp: mat4x4f;
+
+@vertex
+fn main(input: VertexInput) -> VertexOutput {
+    var output: VertexOutput;
+    output.position = mvp * vec4f(input.position, 1.0);
+    output.uv = input.uv;
+    return output;
+}
+```
+
+### Fragment Shader
+
+```wgsl
+@group(0) @binding(1) var textureSampler: sampler;
+@group(0) @binding(2) var texture: texture_2d<f32>;
+
+@fragment
+fn main(@location(0) uv: vec2f) -> @location(0) vec4f {
+    return textureSample(texture, textureSampler, uv);
+}
+```
+
+---
+
+## Three.js WebGPU
+
+```javascript
+import * as THREE from 'three/webgpu';
+import { MeshStandardNodeMaterial } from 'three/nodes';
+
+async function createScene() {
+    const renderer = new THREE.WebGPURenderer();
+    await renderer.init();
+    
+    renderer.setSize(window.innerWidth, window.innerHeight);
+    document.body.appendChild(renderer.domElement);
+    
+    const scene = new THREE.Scene();
+    const camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight);
+    camera.position.z = 5;
+    
+    // Node-based material for WebGPU
+    const material = new MeshStandardNodeMaterial({
+        color: 0x00ff00,
+        roughness: 0.5,
+        metalness: 0.5
+    });
+    
+    const geometry = new THREE.BoxGeometry();
+    const mesh = new THREE.Mesh(geometry, material);
+    scene.add(mesh);
+    
+    function animate() {
+        mesh.rotation.x += 0.01;
+        mesh.rotation.y += 0.01;
+        renderer.render(scene, camera);
+    }
+    
+    renderer.setAnimationLoop(animate);
+}
+```
+
+---
+
+## Common Shader Effects
+
+### Screen Flash
+
+```wgsl
+@group(0) @binding(0) var<uniform> flashAmount: f32;
+@group(0) @binding(1) var<uniform> flashColor: vec3f;
+
+@fragment
+fn main(@location(0) uv: vec2f) -> @location(0) vec4f {
+    let texColor = textureSample(texture, sampler, uv);
+    return mix(texColor, vec4f(flashColor, 1.0), flashAmount);
+}
+```
+
+### Outline Effect
+
+```wgsl
+fn outline(uv: vec2f, size: f32) -> f32 {
+    let offsets = array<vec2f, 4>(
+        vec2f(size, 0.0),
+        vec2f(-size, 0.0),
+        vec2f(0.0, size),
+        vec2f(0.0, -size)
+    );
+    
+    var alpha = 0.0;
+    for (var i = 0; i < 4; i++) {
+        alpha += textureSample(texture, sampler, uv + offsets[i]).a;
+    }
+    return alpha;
+}
+```
+
+---
+
+## Performance Tips
+
+| Tip | Impact |
+|-----|--------|
+| Batch draw calls | High |
+| Use instancing | High |
+| Minimize state changes | Medium |
+| Compress textures (KTX2) | Medium |
+| Use LOD for meshes | Medium |
+| Avoid branching in shaders | Low |
+
+---
+
+## Anti-Patterns
+
+| ❌ Don't | ✅ Do |
+|----------|-------|
+| Load uncompressed textures | Use Basis Universal/KTX2 |
+| Draw call per object | Batch/Instance |
+| Dynamic uniforms per frame | Uniform buffer objects |
+| Complex branching in shader | Precompute |
+| Skip feature detection | Test `navigator.gpu` |
+
+> **Remember:** WebGPU is the future of web graphics. Design for it, with WebGL fallback.