func _process(delta):
    # 使用Performance监控自定义指标
    Performance.get_monitor(Performance.TIME_FPS)
    
    # 手动测量函数耗时
    var start = Time.get_ticks_usec()
    heavy_function()
    var elapsed = Time.get_ticks_usec() - start
    if elapsed > 1000:  # 超过1ms
        print("Warning: heavy_function took %d us" % elapsed)

// 反面示例：500个敌人每帧都执行
void Update() {
    // 每帧检查玩家距离
    float distance = Vector3.Distance(transform.position, player.position);
    if (distance < detectionRange) {
        ChasePlayer();
    }
}

// 优化后：使用协程，每0.2秒检查一次
IEnumerator CheckPlayerDistance() {
    while (true) {
        float distance = Vector3.Distance(transform.position, player.position);
        if (distance < detectionRange) {
            ChasePlayer();
        }
        yield return new WaitForSeconds(0.2f);
    }
}

// 反面示例：每帧调用GetComponent
void Update() {
    GetComponent<Rigidbody>().AddForce(moveDirection * speed);  // 慢！
    GameObject.Find("Player").transform.position = ...;          // 更慢！
}

// 优化后：缓存引用
private Rigidbody rb;
private Transform playerTransform;

void Awake() {
    rb = GetComponent<Rigidbody>();
    playerTransform = GameObject.FindWithTag("Player").transform;
}

void Update() {
    rb.AddForce(moveDirection * speed);
    playerTransform.position = ...;
}

// 反面示例：每次射击都创建新子弹
void Shoot() {
    Instantiate(bulletPrefab, firePoint.position, firePoint.rotation);
}

// 优化后：使用对象池
public class BulletPool : MonoBehaviour {
    private Queue<GameObject> pool = new Queue<GameObject>();
    
    public GameObject GetBullet() {
        if (pool.Count > 0) {
            GameObject bullet = pool.Dequeue();
            bullet.SetActive(true);
            return bullet;
        }
        return Instantiate(bulletPrefab);
    }
    
    public void ReturnBullet(GameObject bullet) {
        bullet.SetActive(false);
        pool.Enqueue(bullet);
    }
}

public class GenericPool<T> where T : Component {
    private T prefab;
    private Queue<T> objects = new Queue<T>();
    private int maxSize;

    public GenericPool(T prefab, int initialSize, int maxSize) {
        this.prefab = prefab;
        this.maxSize = maxSize;
        // 预创建
        for (int i = 0; i < initialSize; i++) {
            T obj = GameObject.Instantiate(prefab);
            obj.gameObject.SetActive(false);
            objects.Enqueue(obj);
        }
    }

    public T Get() {
        T obj;
        if (objects.Count > 0) {
            obj = objects.Dequeue();
        } else {
            obj = GameObject.Instantiate(prefab);
        }
        obj.gameObject.SetActive(true);
        return obj;
    }

    public void Return(T obj) {
        obj.gameObject.SetActive(false);
        if (objects.Count < maxSize) {
            objects.Enqueue(obj);
        } else {
            GameObject.Destroy(obj.gameObject);
        }
    }
}

// 使用示例
var bulletPool = new GenericPool<Bullet>(bulletPrefab, 50, 200);
var bullet = bulletPool.Get();  // 获取子弹
bulletPool.Return(bullet);       // 归还子弹

// 反面示例：轮询模式（每帧检查）
void Update() {
    if (playerHealth <= 0) {
        OnPlayerDeath();
    }
    if (score >= nextLevelScore) {
        LevelUp();
    }
}

// 优化后：事件驱动模式
public class EventBus : MonoBehaviour {
    public static event Action OnPlayerDeath;
    public static event Action<int> OnScoreChanged;

    public static void PlayerDied() => OnPlayerDeath?.Invoke();
    public static void ScoreChanged(int newScore) => OnScoreChanged?.Invoke(newScore);
}

// 订阅事件
void OnEnable() {
    EventBus.OnPlayerDeath += HandlePlayerDeath;
    EventBus.OnScoreChanged += HandleScoreChanged;
}

void OnDisable() {
    EventBus.OnPlayerDeath -= HandlePlayerDeath;
    EventBus.OnScoreChanged -= HandleScoreChanged;
}

// 耗时操作分散到多帧
IEnumerator ProcessLargeData(int[] data) {
    int batchSize = 100;
    for (int i = 0; i < data.Length; i += batchSize) {
        int end = Mathf.Min(i + batchSize, data.Length);
        for (int j = i; j < end; j++) {
            ProcessItem(data[j]);
        }
        yield return null; // 每处理100个元素，让出一帧
    }
}

public class SimpleLOD : MonoBehaviour {
    public MeshRenderer[] lodMeshes; // 从精细到粗糙
    public float[] distances;        // 切换距离

    private Transform cameraTransform;

    void Start() {
        cameraTransform = Camera.main.transform;
    }

    void Update() {
        float distance = Vector3.Distance(transform.position, cameraTransform.position);
        int lodLevel = 0;
        for (int i = 0; i < distances.Length; i++) {
            if (distance > distances[i]) lodLevel = i + 1;
        }
        lodLevel = Mathf.Min(lodLevel, lodMeshes.Length - 1);
        
        for (int i = 0; i < lodMeshes.Length; i++) {
            lodMeshes[i].enabled = (i == lodLevel);
        }
    }
}

// GPU Instancing示例：绘制1000棵树
MaterialPropertyBlock properties = new MaterialPropertyBlock();
for (int i = 0; i < 1000; i++) {
    properties.SetColor("_Color", treeColors[i]);
    properties.SetFloat("_Scale", treeScales[i]);
    Graphics.DrawMeshInstanced(
        treeMesh, 0, treeMaterial,
        treeMatrices[i], // 每个实例的变换矩阵
        properties
    );
}

// 反面示例：在Fragment Shader中进行复杂计算
fixed4 frag(v2f i) : SV_Target {
    float3 normal = UnpackNormal(tex2D(_NormalMap, i.uv));
    float3 viewDir = normalize(_WorldSpaceCameraPos - i.worldPos);
    float3 reflectDir = reflect(-viewDir, normal);
    float4 envSample = texCUBE(_CubeMap, reflectDir);
    // Fresnel计算
    float fresnel = pow(1.0 - saturate(dot(normal, viewDir)), 5.0);
    // 多层混合
    float4 result = lerp(baseColor, envSample, fresnel * _ReflectIntensity);
    return result;
}

// 优化后：简化计算
fixed4 frag(v2f i) : SV_Target {
    float3 normal = UnpackNormal(tex2D(_NormalMap, i.uv));
    // 使用预计算的LUT代替实时Fresnel计算
    float fresnel = tex1D(_FresnelLUT, dot(normal, i.viewDir)).r;
    return lerp(baseColor, envColor, fresnel * _ReflectIntensity);
}

// Unity中设置渲染缩放
Camera.main.allowMSAA = true;
UnityEngine.Rendering.Universal.UniversalRenderPipelineAsset urpAsset = 
    GraphicsSettings.currentRenderPipeline as UnityEngine.Rendering.Universal.UniversalRenderPipelineAsset;
urpAsset.renderScale = 0.75f; // 75%渲染分辨率

// 反面示例：动态加载纹理但从不释放
void LoadCharacterSkin(string skinName) {
    Texture2D tex = Resources.Load<Texture2D>("Skins/" + skinName);
    // 使用纹理...但从未调用 Resources.UnloadUnusedAssets()
}

// 优化后：显式管理资源生命周期
void UnloadCharacterSkin() {
    currentSkin = null;
    Resources.UnloadUnusedAssets();
}

// 反面示例：添加监听但从不移除
void OnEnable() {
    GameManager.OnGameStateChanged += HandleGameStateChange;
    EventBus.OnEnemyKilled += HandleEnemyKilled;
}
// 没有 OnDisable()！

// 优化后：成对添加/移除
void OnEnable() {
    GameManager.OnGameStateChanged += HandleGameStateChange;
    EventBus.OnEnemyKilled += HandleEnemyKilled;
}

void OnDisable() {
    GameManager.OnGameStateChanged -= HandleGameStateChange;
    EventBus.OnEnemyKilled -= HandleEnemyKilled;
}

// 反面示例：静态变量持有GameObject引用
public class GameManager : MonoBehaviour {
    public static GameManager Instance;
    public static GameObject LastLevelBoss; // 这个引用永远不会被释放！
    
    void Awake() {
        Instance = this;
        DontDestroyOnLoad(gameObject);
    }
}

// 优化后：使用WeakReference或显式清理
public class GameManager : MonoBehaviour {
    public static GameManager Instance;
    private GameObject _lastLevelBoss;
    
    public static void ClearReferences() {
        Instance._lastLevelBoss = null;
    }
}

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

public class AssetManager : MonoBehaviour {
    private Dictionary<string, AsyncOperationHandle> loadedAssets 
        = new Dictionary<string, AsyncOperationHandle>();

    public async Task<T> LoadAssetAsync<T>(string key) {
        if (loadedAssets.ContainsKey(key)) {
            return (T)loadedAssets[key].Result;
        }
        
        var handle = Addressables.LoadAssetAsync<T>(key);
        await handle.Task;
        
        if (handle.Status == AsyncOperationStatus.Succeeded) {
            loadedAssets[key] = handle;
            return handle.Result;
        }
        return default;
    }

    public void UnloadAsset(string key) {
        if (loadedAssets.ContainsKey(key)) {
            Addressables.Release(loadedAssets[key]);
            loadedAssets.Remove(key);
        }
    }

    public void UnloadAll() {
        foreach (var handle in loadedAssets.Values) {
            Addressables.Release(handle);
        }
        loadedAssets.Clear();
    }
}

// Unity异步场景加载
public IEnumerator LoadSceneAsync(string sceneName) {
    // 显示加载画面
    loadingScreen.SetActive(true);
    
    AsyncOperation operation = SceneManager.LoadSceneAsync(sceneName);
    operation.allowSceneActivation = false;
    
    while (operation.progress < 0.9f) {
        progressSlider.value = operation.progress;
        yield return null;
    }
    
    // 场景已准备好，等待玩家点击继续
    continueButton.gameObject.SetActive(true);
    yield return new WaitUntil(() => continueClicked);
    
    operation.allowSceneActivation = true;
    loadingScreen.SetActive(false);
}

// 在菜单界面预加载常用资源
public class Preloader : MonoBehaviour {
    private void Start() {
        StartCoroutine(PreloadAssets());
    }

    private IEnumerator PreloadAssets() {
        string[] preloadPaths = {
            "Prefabs/Player",
            "Prefabs/CommonEnemies",
            "Textures/UI",
            "Audio/BGM"
        };

        foreach (string path in preloadPaths) {
            var request = Resources.LoadAsync<UnityEngine.Object>(path);
            yield return request;
        }
    }
}

// 流式加载系统
public class StreamingLoader : MonoBehaviour {
    public float loadDistance = 50f;
    public float unloadDistance = 80f;
    
    private Dictionary<string, bool> loadedScenes = new Dictionary<string, bool>();

    void Update() {
        foreach (var chunk in worldChunks) {
            float distance = Vector3.Distance(player.position, chunk.center);
            
            if (distance < loadDistance && !loadedScenes[chunk.name]) {
                StartCoroutine(LoadChunk(chunk.name));
            }
            else if (distance > unloadDistance && loadedScenes[chunk.name]) {
                StartCoroutine(UnloadChunk(chunk.name));
            }
        }
    }

    IEnumerator LoadChunk(string chunkName) {
        var op = SceneManager.LoadSceneAsync(chunkName, LoadSceneMode.Additive);
        yield return op;
        loadedScenes[chunkName] = true;
    }

    IEnumerator UnloadChunk(string chunkName) {
        var op = SceneManager.UnloadSceneAsync(chunkName);
        yield return op;
        Resources.UnloadUnusedAssets();
        loadedScenes[chunkName] = false;
    }
}

// 检测Steam Deck并调整设置
void DetectSteamDeck() {
    bool isSteamDeck = SystemInfo.deviceModel.Contains("Jupiter") ||
                       SystemInfo.deviceModel.Contains("Galileo");
    
    if (isSteamDeck) {
        Screen.SetResolution(1280, 800, true);
        QualitySettings.SetQualityLevel(steamDeckQualityPreset);
        // 启用FSR
        UnityEngine.Rendering.Universal.UniversalRenderPipelineAsset urp = 
            GraphicsSettings.currentRenderPipeline as UnityEngine.Rendering.Universal.UniversalRenderPipelineAsset;
        urp.renderScale = 0.85f;
    }
}

// 使用Rewired或InControl处理Steam Deck控制器
// 关键：确保所有操作都可以映射到Steam Deck的控制器
// 特别是：触控板映射为鼠标、背键映射为常用操作

// 使用时间增量而不是固定值
void Update() {
    // 正确：使用Time.deltaTime
    transform.position += moveDirection * speed * Time.deltaTime;
    
    // 错误：使用固定值
    // transform.position += moveDirection * speed * 0.016f;
}

// 物理计算使用fixedDeltaTime
void FixedUpdate() {
    rb.AddForce(force * Time.fixedDeltaTime);
}