// 值类型示例 - 不会产生GC
public struct DamageInfo {
    public int damage;
    public Vector3 hitPoint;
    public bool isCritical;
}

// 引用类型示例 - 适合复杂逻辑
public class PlayerController : MonoBehaviour {
    private DamageInfo currentDamage; // 值类型，无GC压力
    private List<Enemy> enemies = new List<Enemy>(); // 引用类型集合
}

// 装箱示例 - 产生GC Alloc
int i = 123;
object obj = i;           // 装箱：值类型→堆上的object
int j = (int)obj;         // 拆箱：object→值类型

// Unity中的常见陷阱
List<object> list = new List<object>();
list.Add(1);              // 装箱！int→object

// 使用泛型避免装箱
List<int> intList = new List<int>();
intList.Add(1);           // 无装箱

// 接口导致的隐式装箱
public interface IValue { int GetValue(); }
public struct MyStruct : IValue { 
    public int value;
    public int GetValue() => value; 
}

IValue val = new MyStruct { value = 10 }; // 装箱！struct→interface
int v = val.GetValue();                   // 虚方法调用

// 标准C#事件 - 推荐用于代码层
public class GameManager {
    public static event Action OnGameStart;
    public static event Action<int> OnScoreChanged;
    
    public void StartGame() {
        OnGameStart?.Invoke();
    }
}

// UnityEvent - 适合Inspector配置
public class Health : MonoBehaviour {
    [SerializeField] 
    private UnityEvent onDeath;  // 设计师可拖拽绑定
    
    public void TakeDamage(float dmg) {
        if (hp <= 0) onDeath.Invoke();
    }
}

// 委托作为回调 - 灵活但需谨慎
public void LoadAssetAsync<T>(string path, Action<T> onComplete) {
    // 异步加载完成后回调
    StartCoroutine(LoadCoroutine(path, onComplete));
}

// Coroutine - Unity传统方式
public IEnumerator LoadSceneAsync(string sceneName) {
    var op = SceneManager.LoadSceneAsync(sceneName);
    while (!op.isDone) {
        progressBar.value = op.progress;
        yield return null;  // 每帧检查
    }
}

// async/await - 现代C#方式
public async Task<Texture2D> DownloadTextureAsync(string url) {
    using (var request = UnityWebRequestTexture.GetTexture(url)) {
        await request.SendWebRequest();  // 非阻塞等待
        if (request.result == UnityWebRequest.Result.Success) {
            return DownloadHandlerTexture.GetContent(request);
        }
        throw new Exception($"Download failed: {request.error}");
    }
}

// 混合使用 - 推荐模式
public async void StartAsyncOperation() {
    // async方法内启动Coroutine
    var coroutineTask = RunCoroutineAsTask(LoadAssetCoroutine());
    await coroutineTask;
}

private IEnumerator LoadAssetCoroutine() {
    // 复杂Unity操作
    yield return new WaitForSeconds(1);
}

// 1. 缓存对象避免重复创建
public class ObjectPool<T> where T : class, new() {
    private Queue<T> pool = new Queue<T>();
    
    public T Get() => pool.Count > 0 ? pool.Dequeue() : new T();
    public void Recycle(T obj) => pool.Enqueue(obj);
}

// 2. 避免LINQ（产生临时对象）
// 差
var enemies = allUnits.Where(u => u.isEnemy).ToList();

// 好
List<Enemy> enemies = new List<Enemy>();
foreach (var unit in allUnits) {
    if (unit.isEnemy) enemies.Add(unit);
}

// 3. 字符串优化
// 差
string path = "Assets/" + folder + "/" + fileName + ".prefab";

// 好
StringBuilder sb = new StringBuilder();
sb.Append("Assets/").Append(folder).Append('/').Append(fileName).Append(".prefab");

// 4. 数组/列表预分配
List<Vector3> points = new List<Vector3>(100); // 预分配容量
points.Clear(); // 复用而不是new

// 5. 使用struct代替class（谨慎）
public struct PathNode {
    public Vector3 position;
    public float gCost;
    public float hCost;
    public float FCost => gCost + hCost;
}

// 常见约束类型
public class GenericConstraints<T> where T : 
    class,           // 必须是引用类型
    new(),           // 必须有默认构造函数
    MonoBehaviour,   // 必须继承自MonoBehaviour
    IComparable<T>,  // 必须实现接口
    unmanaged        // C# 7.3+ 非托管类型（用于指针操作）
{
    public T CreateInstance() => new T(); // 依赖new()约束
}

// Unity实战：组件缓存系统
public class ComponentCache<T> where T : Component {
    private static Dictionary<GameObject, T> cache = new Dictionary<GameObject, T>();
    
    public static T Get(GameObject go) {
        if (!cache.TryGetValue(go, out T comp)) {
            comp = go.GetComponent<T>();
            cache[go] = comp;
        }
        return comp;
    }
}

// 泛型对象池
public class ObjectPool<T> where T : class, IPoolable, new() {
    private Queue<T> pool = new Queue<T>();
    
    public T Get() {
        T item = pool.Count > 0 ? pool.Dequeue() : new T();
        item.OnSpawn();
        return item;
    }
    
    public void Recycle(T item) {
        item.OnRecycle();
        pool.Enqueue(item);
    }
}

public interface IPoolable {
    void OnSpawn();
    void OnRecycle();
}

// 闭包陷阱：循环中的捕获
for (int i = 0; i < 10; i++) {
    // 错误：所有回调都输出10
    buttons[i].onClick.AddListener(() => Debug.Log(i));
    
    // 正确：创建局部副本
    int index = i;
    buttons[i].onClick.AddListener(() => Debug.Log(index));
}

// 内存泄漏：捕获this或大型对象
public class PlayerUI : MonoBehaviour {
    private Texture2D largeTexture; // 大纹理
    
    void Start() {
        // 危险：Lambda捕获了整个this实例
        NetworkManager.OnDataReceived += (data) => {
            UpdateUI(data, this.largeTexture); // 即使销毁UI，NetworkManager还持有引用
        };
    }
    
    void OnDestroy() {
        // 必须取消订阅！
        NetworkManager.OnDataReceived -= handler; // 但匿名Lambda无法移除！
    }
}

// 解决方案：使用具名方法或弱引用
private void OnDataReceivedHandler(byte[] data) {
    UpdateUI(data, largeTexture);
}

void Start() {
    NetworkManager.OnDataReceived += OnDataReceivedHandler;
}

void OnDestroy() {
    NetworkManager.OnDataReceived -= OnDataReceivedHandler; // 正确移除
}

// 标准模式
public class NativeTextureWrapper : IDisposable {
    private IntPtr nativeTexture;
    private bool disposed = false;
    
    public NativeTextureWrapper(int width, int height) {
        nativeTexture = CreateNativeTexture(width, height);
    }
    
    // 受保护虚方法，允许子类重写
    protected virtual void Dispose(bool disposing) {
        if (!disposed) {
            if (disposing) {
                // 释放托管资源
            }
            // 释放非托管资源
            DestroyNativeTexture(nativeTexture);
            nativeTexture = IntPtr.Zero;
            disposed = true;
        }
    }
    
    public void Dispose() {
        Dispose(true);
        GC.SuppressFinalize(this); // 阻止调用终结器
    }
    
    ~NativeTextureWrapper() {
        Dispose(false); // 终结器只释放非托管资源
    }
}

// Unity中需要手动释放的资源
public class ResourceManager {
    // 1. 文件流
    public string ReadFile(string path) {
        using (var stream = new FileStream(path, FileMode.Open))
        using (var reader = new StreamReader(stream)) {
            return reader.ReadToEnd();
        } // 自动调用Dispose
    }
    
    // 2. UnityWebRequest
    public async Task<Texture> DownloadTexture(string url) {
        using (var request = UnityWebRequestTexture.GetTexture(url)) {
            await request.SendWebRequest();
            return DownloadHandlerTexture.GetContent(request);
        } // 释放Native内存
    }
    
    // 3. 渲染纹理
    public void CaptureScreen() {
        var rt = RenderTexture.GetTemporary(1920, 1080);
        // ...使用rt...
        RenderTexture.ReleaseTemporary(rt); // 必须释放回池
    }
    
    // 4. ComputeBuffer
    private ComputeBuffer buffer;
    void OnDestroy() {
        buffer?.Release(); // 必须手动释放GPU内存
    }
}

// 反射的性能问题
public class ReflectionExample {
    private Type playerType = typeof(Player);
    
    // 慢：每次反射获取方法
    public void CallMethodSlow(Player player) {
        var method = playerType.GetMethod("TakeDamage"); // 搜索元数据
        method.Invoke(player, new object[] { 10 });      // 装箱+虚调用
    }
    
    // 快：缓存MemberInfo
    private static readonly MethodInfo takeDamageMethod = 
        typeof(Player).GetMethod("TakeDamage", BindingFlags.Instance | BindingFlags.Public);
    
    public void CallMethodFast(Player player) {
        takeDamageMethod.Invoke(player, new object[] { 10 }); // 仍有一次装箱
    }
    
    // 最快：表达式树编译委托（C#高级技巧）
    private static readonly Action<Player, int> takeDamageDelegate = 
        (Action<Player, int>)Delegate.CreateDelegate(
            typeof(Action<Player, int>), 
            null, 
            typeof(Player).GetMethod("TakeDamage")
        );
    
    public void CallMethodFastest(Player player) {
        takeDamageDelegate(player, 10); // 直接调用，无装箱
    }
}

// Unity特定：SerializedObject和Inspector
public class EditorTool {
    public void ModifyProperty(SerializedObject so, string propertyName, float value) {
        // 反射访问Inspector属性
        var prop = so.FindProperty(propertyName);
        prop.floatValue = value;
        so.ApplyModifiedProperties();
    }
}

// 属性标记与反射结合
[AttributeUsage(AttributeTargets.Method)]
public class ConsoleCommandAttribute : Attribute {
    public string CommandName { get; }
    public ConsoleCommandAttribute(string name) => CommandName = name;
}

public class CommandSystem {
    private Dictionary<string, MethodInfo> commands = new Dictionary<string, MethodInfo>();
    
    [RuntimeInitializeOnLoadMethod]
    public static void Init() {
        var methods = AppDomain.CurrentDomain.GetAssemblies()
            .SelectMany(a => a.GetTypes())
            .SelectMany(t => t.GetMethods())
            .Where(m => m.GetCustomAttribute<ConsoleCommandAttribute>() != null);
        
        foreach (var method in methods) {
            var attr = method.GetCustomAttribute<ConsoleCommandAttribute>();
            commands[attr.CommandName] = method;
        }
    }
}

// Span<T> - 栈上内存视图（C# 7.2+）
public void ProcessDataSpan(byte[] data) {
    // 零分配切片
    Span<byte> header = data.AsSpan(0, 4);
    Span<byte> body = data.AsSpan(4);
    
    // 修改会反映到原数组
    header[0] = 0xFF;
    
    // 栈上分配（小心栈溢出）
    Span<int> stackArray = stackalloc int[100];
    
    // 字符串处理零分配
    string csv = "100,200,300";
    ReadOnlySpan<char> span = csv.AsSpan();
    int comma1 = span.IndexOf(',');
    int value1 = int.Parse(span.Slice(0, comma1)); // 无string分配
}

// Memory<T> - 堆上，可异步使用
public async Task ProcessStreamAsync(Stream stream) {
    byte[] buffer = ArrayPool<byte>.Shared.Rent(4096);
    try {
        Memory<byte> memory = buffer;
        int read = await stream.ReadAsync(memory);
        ProcessData(memory.Span.Slice(0, read));
    } finally {
        ArrayPool<byte>.Shared.Return(buffer);
    }
}

// Unity实际应用：网络协议解析
public class ProtocolParser {
    public static Packet ParsePacket(ReadOnlySpan<byte> data) {
        var packet = new Packet {
            Header = new PacketHeader {
                Magic = BinaryPrimitives.ReadUInt16BigEndian(data.Slice(0, 2)),
                Length = BinaryPrimitives.ReadUInt32BigEndian(data.Slice(2, 4)),
                CmdId = BinaryPrimitives.ReadUInt16BigEndian(data.Slice(6, 2))
            }
        };
        packet.Payload = data.Slice(8, (int)packet.Header.Length).ToArray();
        return packet;
    }
}

// 注意：Unity 2020+ 支持，但IL2CPP有限制
// 不能作为字段、不能泛型约束、异步方法需谨慎

public class LifecycleDemo : MonoBehaviour {
    // 脚本实例化时调用（即使未启用），用于内部初始化
    void Awake() {
        // 缓存组件引用
        rb = GetComponent<Rigidbody>();
        // 初始化内部状态，不依赖其他对象
    }
    
    // 对象启用时调用（包括脚本启用）
    void OnEnable() {
        // 注册事件、加入管理器列表
        GameManager.Instance.RegisterPlayer(this);
    }
    
    // 第一帧Update前调用，依赖其他对象的初始化
    void Start() {
        // 查找其他对象、复杂初始化
        target = GameObject.FindWithTag("Enemy")?.transform;
    }
    
    // 固定时间间隔（默认0.02s），物理相关
    void FixedUpdate() {
        rb.AddForce(Vector3.up * jumpForce); // 物理操作
    }
    
    // 每帧调用，输入处理和主要逻辑
    void Update() {
        float h = Input.GetAxis("Horizontal");
        transform.Translate(h * speed * Time.deltaTime, 0, 0);
    }
    
    // 所有Update后调用，相机跟随等
    void LateUpdate() {
        if (cameraFollow)
            Camera.main.transform.position = transform.position + offset;
    }
    
    // 对象禁用时调用
    void OnDisable() {
        GameManager.Instance.UnregisterPlayer(this); // 必须取消注册
    }
    
    // 对象销毁时调用
    void OnDestroy() {
        // 清理资源、保存数据
    }
}

// 协程本质：编译器生成的状态机
public IEnumerator MyCoroutine() {
    Debug.Log("Start");      // State 0
    yield return null;       // 暂停，下一帧继续
    Debug.Log("Frame 1");    // State 1
    yield return new WaitForSeconds(1); // 暂停1秒
    Debug.Log("After 1s");   // State 2
}

// 不同yield指令的行为
public class YieldInstructions {
    // 下一帧继续（Update后）
    yield return null;
    
    // 等待固定帧数
    yield return new WaitForEndOfFrame();  // 渲染后，截图用
    yield return new WaitForFixedUpdate(); // FixedUpdate后
    yield return new WaitForSeconds(1.5f); // 等待秒数（受Time.timeScale影响）
    yield return new WaitForSecondsRealtime(1.5f); // 不受timeScale影响
    
    // 等待条件
    yield return new WaitUntil(() => condition);   // 条件为true继续
    yield return new WaitWhile(() => condition);   // 条件为false继续
    
    // 嵌套协程
    yield return StartCoroutine(AnotherCoroutine()); // 等待另一个完成
    
    // 自定义YieldInstruction（高级）
    yield return new WaitForAsyncOperation(operation);
}

// 协程停止的正确方式
public class CoroutineManager : MonoBehaviour {
    private Coroutine currentCoroutine;
    
    void Start() {
        currentCoroutine = StartCoroutine(LongRunningTask());
    }
    
    void OnDisable() {
        if (currentCoroutine != null) {
            StopCoroutine(currentCoroutine); // 停止特定协程
            // StopAllCoroutines(); // 停止所有
        }
    }
    
    // 更安全的模式：使用标志位
    private bool shouldRun = true;
    IEnumerator SafeCoroutine() {
        while (shouldRun) {
            // 工作...
            yield return null;
        }
    }
}

public class PhysicsSettings : MonoBehaviour {
    [Header("刚体类型选择")]
    [SerializeField] private Rigidbody rb;
    
    void ConfigureRigidbody() {
        // 1. 非Kinematic - 物理控制（默认）
        rb.isKinematic = false;
        rb.useGravity = true;
        // 适合：受重力、被力推动、物理交互的角色
        
        // 2. Kinematic - 代码控制
        rb.isKinematic = true;
        // 适合：平台、门、脚本驱动的动画物体
        // 注意：Kinematic物体不会被力影响，但会影响其他物体
        
        // 3. 动态切换
        rb.isKinematic = false; // 爆炸时变成物理驱动
        rb.AddExplosionForce(1000, transform.position, 10);
    }
    
    void ConfigureCollisionDetection() {
        // 离散检测（默认）- 性能最好，可能穿墙
        rb.collisionDetectionMode = CollisionDetectionMode.Discrete;
        
        // 连续检测 - 防止高速物体穿过薄碰撞体
        rb.collisionDetectionMode = CollisionDetectionMode.Continuous;
        // 适合：玩家控制的快速移动物体
        
        // 动态连续 - 对静态物体用连续，对动态用离散
        rb.collisionDetectionMode = CollisionDetectionMode.ContinuousDynamic;
        // 适合：可能撞击静态墙的快速物体
        
        // 连续推测 - 最精确，性能最差
        rb.collisionDetectionMode = CollisionDetectionMode.ContinuousSpeculative;
        // 适合：极其重要的碰撞，如子弹
    }
}

// 物理性能优化
public class PhysicsOptimizer : MonoBehaviour {
    void Optimize() {
        // 1. 层碰撞矩阵 - 禁用不需要的层碰撞
        // Edit → Project Settings → Physics → Layer Collision Matrix
        
        // 2. 简化碰撞体
        // MeshCollider → BoxCollider/SphereCollider
        // 复杂Mesh用凸包（Convex）
        
        // 3. 物理更新频率
        Time.fixedDeltaTime = 0.02f; // 50Hz，根据需求调整
        
        // 4. 休眠设置
        rb.sleepThreshold = 0.005f; // 速度低于此值进入休眠
    }
}

// Draw Call优化策略
public class DrawCallOptimizer : MonoBehaviour {
    void Start() {
        // 1. 静态合批（Static Batching）
        // 标记为Static的物体，编辑器时合并网格
        // 限制：顶点数<900，同材质
        
        // 2. 动态合批（Dynamic Batching）
        // 运行时自动合并小物体
        // 限制：顶点属性<900，缩放一致，不使用光照贴图
        
        // 3. GPU Instancing
        // 同Mesh同材质的大量物体
        MaterialPropertyBlock props = new MaterialPropertyBlock();
        MeshRenderer renderer = GetComponent<MeshRenderer>();
        props.SetColor("_Color", Color.red);
        renderer.SetPropertyBlock(props); // 不同颜色但不打断合批
        
        // 4. SRP Batcher（URP/HDRP）
        // 基于Shader变体合批，只要Shader相同就能合批
        // 即使材质不同，只要Shader变体相同
    }
    
    // 运行时优化检查
    void CheckStats() {
        // Window → Analysis → Frame Debugger 查看实际Draw Call
        // Stats窗口的Batches是合批后的数量，SetPass calls是Shader切换次数
        
        // 优化目标：Batches < 200（移动端），SetPass calls < 100
    }
}

// 材质和纹理优化
public class AssetOptimizer {
    void Optimize() {
        // 图集（Atlas）- 减少纹理切换
        // Sprite Packer或TexturePacker
        
        // Mipmap - 远距离用小纹理，省带宽
        TextureImporter importer = AssetImporter.GetAtPath(path) as TextureImporter;
        importer.mipmapEnabled = true;
        
        // 压缩格式
        // Android: ASTC, iOS: ASTC/PVRTC
    }
}

// 通用对象池管理器
public class ObjectPool<T> where T : Component, IPoolable {
    private T prefab;
    private Transform container;
    private Queue<T> pool = new Queue<T>();
    private HashSet<T> activeObjects = new HashSet<T>();
    
    public ObjectPool(T prefab, int initialSize, Transform container = null) {
        this.prefab = prefab;
        this.container = container ?? new GameObject($"Pool_{prefab.name}").transform;
        
        // 预加载
        for (int i = 0; i < initialSize; i++) {
            CreateInstance();
        }
    }
    
    private T CreateInstance() {
        T instance = Object.Instantiate(prefab, container);
        instance.gameObject.SetActive(false);
        pool.Enqueue(instance);
        return instance;
    }
    
    public T Get(Vector3 position = default, Quaternion rotation = default, Transform parent = null) {
        T instance;
        if (pool.Count == 0) {
            instance = CreateInstance();
            Debug.LogWarning($"Pool {prefab.name} expanded!");
        } else {
            instance = pool.Dequeue();
        }
        
        activeObjects.Add(instance);
        
        // 重置Transform
        instance.transform.SetParent(parent);
        instance.transform.position = position;
        instance.transform.rotation = rotation;
        instance.gameObject.SetActive(true);
        
        instance.OnSpawn();
        return instance;
    }
    
    public void Recycle(T instance) {
        if (!activeObjects.Contains(instance)) return;
        
        instance.OnRecycle();
        instance.gameObject.SetActive(false);
        instance.transform.SetParent(container);
        
        activeObjects.Remove(instance);
        pool.Enqueue(instance);
    }
    
    public void RecycleAll() {
        foreach (var obj in activeObjects.ToArray()) {
            Recycle(obj);
        }
    }
}

// 池化对象接口
public interface IPoolable {
    void OnSpawn();   // 从池中取出时调用
    void OnRecycle(); // 回收到池时调用
}

// 使用示例：子弹系统
public class Bullet : MonoBehaviour, IPoolable {
    [SerializeField] private float speed = 50f;
    [SerializeField] private float lifeTime = 3f;
    
    private float spawnTime;
    private ObjectPool<Bullet> pool;
    
    public void SetPool(ObjectPool<Bullet> pool) => this.pool = pool;
    
    public void OnSpawn() {
        spawnTime = Time.time;
        StartCoroutine(LifeCycle());
    }
    
    public void OnRecycle() {
        StopAllCoroutines();
        // 清理状态
        GetComponent<Rigidbody>().velocity = Vector3.zero;
    }
    
    void Update() {
        transform.Translate(Vector3.forward * speed * Time.deltaTime);
    }
    
    IEnumerator LifeCycle() {
        yield return new WaitForSeconds(lifeTime);
        pool?.Recycle(this);
    }
    
    void OnTriggerEnter(Collider other) {
        // 命中逻辑...
        pool?.Recycle(this);
    }
}

// 管理器集成
public class BulletManager : MonoBehaviour {
    [SerializeField] private Bullet bulletPrefab;
    private ObjectPool<Bullet> bulletPool;
    
    void Start() {
        bulletPool = new ObjectPool<Bullet>(bulletPrefab, 50, transform);
    }
    
    public void Fire(Vector3 pos, Quaternion rot) {
        var bullet = bulletPool.Get(pos, rot);
        bullet.SetPool(bulletPool);
    }
}

// Animator架构
// Animator (Component) → RuntimeAnimatorController → AnimatorController (Asset)
//                                           ↓
//                                    AnimatorStateMachine
//                                           ↓
//                                    AnimatorState → Motion (AnimationClip)

public class AnimatorOptimization : MonoBehaviour {
    [SerializeField] private Animator animator;
    
    void SetupAnimator() {
        // 1. 使用Animator Override Controller复用状态机
        // 基础Controller定义状态结构，Override替换具体Clip
        var overrideController = new AnimatorOverrideController(animator.runtimeAnimatorController);
        overrideController["Idle"] = newIdleClip; // 替换特定状态
        animator.runtimeAnimatorController = overrideController;
    }
    
    void OptimizeSettings() {
        // 2. Culling Mode优化
        animator.cullingMode = AnimatorCullingMode.CullUpdateTransforms;
        // CullCompletely：不可见时完全停止（适合背景NPC）
        // CullUpdateTransforms：不可见时停止位置更新，但动画继续
        // AlwaysAnimate：始终更新（主角）
        
        // 3. 关闭不需要的IK
        animator.applyRootMotion = false; // 不需要根运动时关闭
    }
    
    void EfficientParameters() {
        // 4. 使用Hash代替字符串（重要！）
        int speedHash = Animator.StringToHash("Speed");
        int isRunningHash = Animator.StringToHash("IsRunning");
        
        // 差：每次调用都计算Hash
        animator.SetFloat("Speed", 5f);
        
        // 好：缓存Hash
        animator.SetFloat(speedHash, 5f);
        
        // 5. 批量设置（减少Native调用）
        animator.SetFloat(speedHash, currentSpeed);
        animator.SetBool(isRunningHash, isRunning);
    }
}

// 状态机设计优化
public class StateMachineDesign {
    // 避免：大量过渡条件复杂的状态机
    // 推荐：使用Blend Tree合并相似状态
    
    // Blend Tree示例：移动方向混合
    // 2D Freeform Directional混合8方向行走动画
    // 参数：VelocityX, VelocityY
    // 比8个独立状态+过渡更高效
}

public class RaycastSystem : MonoBehaviour {
    // 1. 基础射线检测
    void BasicRaycast() {
        Ray ray = new Ray(transform.position, transform.forward);
        if (Physics.Raycast(ray, out RaycastHit hit, 100f)) {
            Debug.Log($"Hit: {hit.collider.name}");
        }
    }
    
    // 2. 不同类型射线检测
    void RaycastTypes() {
        // 单点检测
        Physics.Raycast(origin, direction, out hit, maxDistance, layerMask);
        
        // 返回所有命中（穿透检测）
        RaycastHit[] hits = Physics.RaycastAll(origin, direction, maxDistance);
        
        // 非分配版本（避免GC）
        int count = Physics.RaycastNonAlloc(origin, direction, hitBuffer, maxDistance);
        
        // 形状投射
        Physics.SphereCast(ray, radius, out hit, maxDistance); // 球形
        Physics.BoxCast(origin, halfExtents, direction, out hit, orientation, maxDistance); // 盒形
        Physics.CapsuleCast(point1, point2, radius, direction, out hit); // 胶囊形
        
        // 区域检测
        Collider[] colliders = Physics.OverlapSphere(center, radius, layerMask);
        int count2 = Physics.OverlapSphereNonAlloc(center, radius, colliderBuffer);
    }
    
    // 3. 批量射线优化（AI视野检测）
    void OptimizeAIVision() {
        // 差：每个敌人每帧N条射线
        // 好：分层检测，先 broad phase 再 narrow phase
        
        // 第一步：距离筛选（便宜）
        if (Vector3.Distance(enemy.position, player.position) > visionRange) return;
        
        // 第二步：角度筛选（便宜）
        Vector3 dirToPlayer = (player.position - enemy.position).normalized;
        if (Vector3.Dot(enemy.forward, dirToPlayer) < Mathf.Cos(visionAngle * 0.5f * Mathf.Deg2Rad)) return;
        
        // 第三步：射线确认（昂贵，但执行次数少）
        if (Physics.Raycast(enemy.position + eyeOffset, dirToPlayer, out hit, visionRange, obstacleLayer)) {
            if (hit.collider.CompareTag("Player")) {
                // 发现玩家
            }
        }
    }
    
    // 4. 物理场景查询（Job System加速）
    void JobSystemRaycast() {
        // Unity 2018.3+ 支持批量射线Job化
        // 使用RaycastCommand.ScheduleBatch在后台线程执行
    }
}

// 优化配置
public class PhysicsSettings {
    void Configure() {
        // 层遮罩（LayerMask）精确控制检测层
        int enemyLayer = LayerMask.GetMask("Enemy");
        int obstacleLayer = LayerMask.GetMask("Wall", "Building");
        
        // 碰撞矩阵优化
        // Edit → Project Settings → Physics：禁用不需要的层碰撞
        
        // 射线检测频率控制
        // 不需要每帧检测的，用协程分帧或降低频率
    }
}

// Prefab结构示例
// BaseEnemy.prefab (基础敌人)
//   ├── Model
//   ├── Collider
//   └── BaseAI (Script)

// EliteEnemy.prefab (Variant)
//   继承自 BaseEnemy
//   覆盖：MaxHP = 200 (Base: 100)
//   添加：EliteEffect (Particle)
//   删除：无（不能删继承的，只能禁用）

// BossEnemy.prefab (Variant)
//   继承自 BaseEnemy
//   覆盖：Scale = 2x
//   添加：BossUI (Canvas)

// Nested Prefab示例
// Player.prefab
//   ├── Visual (Mesh)
//   ├── WeaponSlot (Empty)
//   │     └── Sword.prefab (Nested，可替换为Axe.prefab)
//   └── Inventory.prefab (Nested，复用UI组件)

public class PrefabWorkflow : MonoBehaviour {
    // 运行时实例化
    [SerializeField] private GameObject enemyPrefab;
    
    void SpawnEnemy() {
        // 实例化Prefab
        GameObject enemy = Instantiate(enemyPrefab, position, rotation);
        
        // 修改实例不影响Prefab资产
        enemy.GetComponent<Enemy>().hp = 150;
        
        // 应用回Prefab（Editor Only）
        // PrefabUtility.ApplyPrefabInstance(enemy, InteractionMode.UserAction);
    }
    
    // Prefab变体编程
    void HandleVariants() {
        // 获取Prefab路径
        string path = PrefabUtility.GetPrefabAssetPathOfNearestInstanceRoot(gameObject);
        
        // 检查是否是Variant
        if (PrefabUtility.IsPartOfVariantPrefab(gameObject)) {
            GameObject basePrefab = PrefabUtility.GetCorrespondingObjectFromSource(gameObject);
            Debug.Log($"Variant of: {basePrefab.name}");
        }
    }
}

// 最佳实践
public class PrefabBestPractices {
    // 1. 设计可组合的Prefab
    // 武器、装备、特效都做成独立Prefab，Nested到角色上
    
    // 2. 使用Prefab Mode编辑
    // 双击Prefab资产进入隔离编辑环境
    
    // 3. Overrides窗口管理差异
    // 查看实例与Prefab的所有差异，选择性应用或回退
    
    // 4. 避免过度嵌套
    // 嵌套层级太深影响编辑性能，建议<5层
}

// 安装：Package Manager → Input System

// 1. 定义Input Actions资产
// Create → Input Actions
// 配置Action Maps（如Gameplay、Menu）
// 配置Actions（如Move、Jump、Attack）
// 绑定键位：WASD/摇杆 → Move，Space/按钮 → Jump

// 2. 代码中使用
using UnityEngine.InputSystem;

public class NewInputHandler : MonoBehaviour {
    private PlayerInput playerInput;
    private InputAction moveAction;
    private InputAction jumpAction;
    
    void Awake() {
        playerInput = GetComponent<PlayerInput>();
        
        // 获取动作引用
        moveAction = playerInput.actions["Move"];
        jumpAction = playerInput.actions["Jump"];
        
        // 事件绑定（推荐）
        jumpAction.performed += OnJump;
        jumpAction.canceled += OnJumpReleased;
    }
    
    void Update() {
        // 读取值
        Vector2 moveInput = moveAction.ReadValue<Vector2>();
        MoveCharacter(moveInput);
    }
    
    void OnJump(InputAction.CallbackContext context) {
        // context包含按键力度、时间等信息
        float pressStrength = context.ReadValue<float>();
        Jump(pressStrength);
    }
    
    void OnDestroy() {
        jumpAction.performed -= OnJump; // 必须取消订阅
    }
}

// 3. 交互处理器（Interactions）
// Hold：长按触发
// Press：按下/释放触发
// Tap：轻触触发
// SlowTap：缓慢按下触发
// MultiTap：多次点击

// 4. 处理器（Processors）
// Normalize：向量归一化
// Scale：数值缩放
// Invert：输入反转
// AxisDeadzone：摇杆死区

// 5. 控制方案（Control Schemes）
// Keyboard&Mouse、Gamepad、Touch
// 自动切换或手动切换
public void SwitchScheme(string schemeName) {
    playerInput.SwitchCurrentControlScheme(schemeName);
}

// 6. 设备配对（分屏游戏）
public void PairDevices() {
    var keyboard = Keyboard.current;
    var gamepad = Gamepad.current;
    
    // 玩家1用键盘，玩家2用手柄
    PlayerInput.Instantiate(playerPrefab, controlScheme: "Keyboard", pairWithDevice: keyboard);
    PlayerInput.Instantiate(playerPrefab, controlScheme: "Gamepad", pairWithDevice: gamepad);
}

// 1. 基础数据配置
[CreateAssetMenu(fileName = "WeaponData", menuName = "Game/Weapon Data")]
public class WeaponData : ScriptableObject {
    public string weaponName;
    public int damage;
    public float fireRate;
    public GameObject projectilePrefab;
    public AudioClip fireSound;
    
    [TextArea(3, 10)]
    public string description;
}

// 使用：创建资产文件，拖拽配置，多个对象共享
public class Weapon : MonoBehaviour {
    [SerializeField] private WeaponData data; // 引用资产
    
    void Fire() {
        Instantiate(data.projectilePrefab);
        AudioSource.PlayClipAtPoint(data.fireSound, transform.position);
    }
}

// 2. 运行时数据共享（非序列化修改）
public class RuntimeData : ScriptableObject {
    [System.NonSerialized] public int currentAmmo;
    [System.NonSerialized] public float durability;
    
    public void Reset() {
        currentAmmo = 30;
        durability = 100f;
    }
}

// 3. 事件系统（解耦架构）
[CreateAssetMenu(menuName = "Events/Void Event")]
public class GameEvent : ScriptableObject {
    private List<GameEventListener> listeners = new List<GameEventListener>();
    
    public void Raise() {
        for (int i = listeners.Count - 1; i >= 0; i--) {
            listeners[i].OnEventRaised();
        }
    }
    
    public void RegisterListener(GameEventListener listener) => listeners.Add(listener);
    public void UnregisterListener(GameEventListener listener) => listeners.Remove(listener);
}

// 监听者组件
public class GameEventListener : MonoBehaviour {
    [SerializeField] private GameEvent gameEvent;
    [SerializeField] private UnityEvent response;
    
    void OnEnable() => gameEvent.RegisterListener(this);
    void OnDisable() => gameEvent.UnregisterListener(this);
    public void OnEventRaised() => response.Invoke();
}

// 4. 与MonoBehaviour对比
/*
特性              ScriptableObject          MonoBehaviour
─────────────────────────────────────────────────────────
存在场景          否（资产文件）            是（GameObject）
性能开销          极低（无Transform）       高（每帧更新）
数据共享          多对象引用同一资产        每个实例独立
持久化            资产修改自动保存          运行时修改不保存
生命周期          与资产同生命周期          与GameObject绑定
*/

// 5. 高级用法：编辑器工具
public class EditorToolExample {
    [MenuItem("Tools/Generate Enemy Database")]
    static void GenerateDatabase() {
        var database = ScriptableObject.CreateInstance<EnemyDatabase>();
        
        // 扫描文件夹创建敌人数据
        var guids = AssetDatabase.FindAssets("t:GameObject", new[] { "Assets/Prefabs/Enemies" });
        foreach (var guid in guids) {
            var path = AssetDatabase.GUIDToAssetPath(guid);
            var prefab = AssetDatabase.LoadAssetAtPath<GameObject>(path);
            // 添加到database...
        }
        
        AssetDatabase.CreateAsset(database, "Assets/Resources/EnemyDatabase.asset");
        AssetDatabase.SaveAssets();
    }
}

// Profiler标记自定义代码段
using UnityEngine.Profiling;

public class CustomProfiler {
    void HeavyOperation() {
        Profiler.BeginSample("MyHeavyOperation");
        // 耗时操作
        for (int i = 0; i < 1000; i++) {
            ComplexCalculation();
        }
        Profiler.EndSample();
    }
    
    // 内存分析标记
    void AllocateMemory() {
        Profiler.BeginSample("AllocateMemory");
        var texture = new Texture2D(1024, 1024);
        Profiler.EndSample();
    }
}

// Frame Debugger使用
// Window → Analysis → Frame Debugger
// 点击Enable查看当前帧
// 左侧列表查看每个Draw Call
// 查看Shader、纹理、渲染状态

// Static Batching
// 条件：标记为Static，同材质，合并后顶点<900（GLES2）或65535（GLES3）
// 发生时机：构建时或运行时加载
// 内存代价：合并后的Mesh占用更多内存

// Dynamic Batching
// 条件：顶点属性<900，同材质，缩放一致，不使用光照贴图，Shader支持
// 发生时机：运行时每帧
// CPU代价：每帧计算合并，顶点变换在CPU

// GPU Instancing
// 条件：同Mesh同材质，Shader支持instancing
// 限制：不能访问实例特定数据（除非用MaterialPropertyBlock）

public class BatchingExample {
    void Setup() {
        // Static Batching：编辑器标记物体为Static
        // 或代码设置：gameObject.isStatic = true;
        
        // GPU Instancing启用
        var renderer = GetComponent<MeshRenderer>();
        var material = renderer.material;
        material.enableInstancing = true; // 必须勾选
        
        // 大量物体时，Unity自动合并为Instanced Draw Call
    }
    
    // 检查合批情况
    void CheckBatching() {
        // Frame Debugger查看实际Draw Call
        // Stats窗口的Batches是优化后的数量
        // Saved by batching显示节省的Draw Call数
    }
}

// SRP Batcher（URP/HDRP）
// 条件：Shader相同（变体相同）
// 优势：材质属性在GPU内存连续存储，切换材质不断开Batch
public class SRPBatcherNote {
    // 即使材质球不同，只要Shader变体相同，就能合批
    // 查看：Frame Debugger中SRP Batcher项
}

// LOD Group组件配置
// 1. 创建空物体，添加LOD Group组件
// 2. 设置LOD等级（LOD0最近，LOD3最远）
// 3. 每个等级拖入对应模型（高模→低模→Billboard）
// 4. 调整屏幕占比阈值（拖动分界线）

public class LODSystem : MonoBehaviour {
    [SerializeField] private LODGroup lodGroup;
    
    void SetupLOD() {
        // 代码配置LOD
        var lods = new LOD[3];
        
        // LOD0: 100% - 60%屏幕占比，使用高模
        lods[0] = new LOD(0.6f, new Renderer[] { highMeshRenderer });
        
        // LOD1: 60% - 30%，使用中模
        lods[1] = new LOD(0.3f, new Renderer[] { mediumMeshRenderer });
        
        // LOD2: 30% - 10%，使用低模
        lods[2] = new LOD(0.1f, new Renderer[] { lowMeshRenderer });
        
        lodGroup.SetLODs(lods);
        lodGroup.RecalculateBounds();
    }
    
    // LOD交叉淡入淡出
    void SetupCrossFade() {
        lodGroup.fadeMode = LODFadeMode.CrossFade;
        lodGroup.animateCrossFading = true;
        // 需要Shader支持LOD_FADE_CROSSFADE关键字
    }
    
    // 获取当前LOD等级
    void CheckCurrentLOD() {
        int lodIndex = lodGroup.GetCurrentLODIndex(Camera.main);
        Debug.Log($"Current LOD: {lodIndex}");
    }
}

// LOD优化技巧
public class LODOptimization {
    // 1. 遮挡剔除配合LOD
    // 远处物体先被Occlusion Culling剔除，再考虑LOD
    
    // 2. 阴影LOD
    // Quality Settings → Shadows → Shadow Resolution根据距离调整
    
    // 3. 动画LOD
    // Animator的Culling Mode配合距离禁用远处动画
    
    // 4. 代码控制LOD偏移
    void AdjustLOD() {
        // 性能紧张时整体降低LOD等级
        QualitySettings.lodBias = 2.0f; // 默认1，越大越早切换到低LOD
        QualitySettings.maximumLODLevel = 1; // 最高使用LOD1，禁用LOD0
    }
}

// 完整泛型对象池实现
public class ObjectPool<T> where T : Component, IPoolable {
    private readonly T prefab;
    private readonly Transform container;
    private readonly Queue<T> available = new Queue<T>();
    private readonly HashSet<T> inUse = new HashSet<T>();
    private readonly int maxSize;
    private int createdCount;
    
    public int AvailableCount => available.Count;
    public int InUseCount => inUse.Count;
    public int TotalCreated => createdCount;
    
    public ObjectPool(T prefab, int initialSize, int maxSize = 100, Transform container = null) {
        this.prefab = prefab;
        this.maxSize = maxSize;
        this.container = container ?? new GameObject($"Pool_{prefab.name}").transform;
        
        Preload(initialSize);
    }
    
    private void Preload(int count) {
        for (int i = 0; i < count && createdCount < maxSize; i++) {
            CreateInstance();
        }
    }
    
    private T CreateInstance() {
        T instance = Object.Instantiate(prefab, container);
        instance.gameObject.SetActive(false);
        available.Enqueue(instance);
        createdCount++;
        return instance;
    }
    
    public T Get(Vector3 position = default, Quaternion rotation = default, Transform parent = null) {
        T instance;
        
        if (available.Count == 0) {
            if (createdCount >= maxSize) {
                Debug.LogWarning($"Pool {prefab.name} reached max size {maxSize}!");
                // 回收最旧的使用中对象或扩展
                return null;
            }
            instance = CreateInstance();
        } else {
            instance = available.Dequeue();
        }
        
        // 重置状态
        instance.transform.SetParent(parent);
        instance.transform.position = position;
        instance.transform.rotation = rotation;
        instance.gameObject.SetActive(true);
        
        inUse.Add(instance);
        instance.OnSpawn();
        
        return instance;
    }
    
    public void Recycle(T instance) {
        if (!inUse.Contains(instance)) {
            Debug.LogWarning($"Trying to recycle object not from pool: { 我将继续完成剩余的面试题目，确保覆盖所有50道题。

---

### 题目24续：对象池完整实现

**详细解答（续）：**

```csharp
            Debug.LogWarning($"Trying to recycle object not from pool: {instance.name}");
            return;
        }
        
        instance.OnRecycle();
        instance.gameObject.SetActive(false);
        instance.transform.SetParent(container);
        instance.transform.localPosition = Vector3.zero;
        
        inUse.Remove(instance);
        available.Enqueue(instance);
    }
    
    public void RecycleAll() {
        // 避免遍历时修改集合
        var tempList = new List<T>(inUse);
        foreach (var item in tempList) {
            Recycle(item);
        }
    }
    
    public void Clear() {
        RecycleAll();
        while (available.Count > 0) {
            var item = available.Dequeue();
            Object.Destroy(item.gameObject);
        }
        createdCount = 0;
    }
}

// 池化对象接口
public interface IPoolable {
    void OnSpawn();   // 从池取出时初始化
    void OnRecycle(); // 回池时清理
}

// 使用示例：子弹系统
public class Bullet : MonoBehaviour, IPoolable {
    [SerializeField] private float speed = 50f;
    [SerializeField] private float lifetime = 3f;
    [SerializeField] private TrailRenderer trail;
    
    private float spawnTime;
    private ObjectPool<Bullet> pool;
    private Coroutine lifetimeCoroutine;
    
    public void SetPool(ObjectPool<Bullet> pool) => this.pool = pool;
    
    public void OnSpawn() {
        spawnTime = Time.time;
        trail?.Clear(); // 清除拖尾
        
        lifetimeCoroutine = StartCoroutine(LifetimeCheck());
    }
    
    public void OnRecycle() {
        if (lifetimeCoroutine != null) {
            StopCoroutine(lifetimeCoroutine);
            lifetimeCoroutine = null;
        }
        // 停止所有物理运动
        if (TryGetComponent<Rigidbody>(out var rb)) {
            rb.velocity = Vector3.zero;
            rb.angularVelocity = Vector3.zero;
        }
    }
    
    void Update() {
        transform.Translate(Vector3.forward * speed * Time.deltaTime);
    }
    
    IEnumerator LifetimeCheck() {
        yield return new WaitForSeconds(lifetime);
        pool?.Recycle(this);
    }
    
    void OnTriggerEnter(Collider other) {
        // 命中效果...
        pool?.Recycle(this);
    }
}

// 管理器
public class BulletManager : MonoBehaviour {
    [SerializeField] private Bullet bulletPrefab;
    [SerializeField] private int poolSize = 100;
    
    private ObjectPool<Bullet> pool;
    
    void Start() {
        pool = new ObjectPool<Bullet>(bulletPrefab, poolSize, 200, transform);
    }
    
    public void Fire(Vector3 position, Quaternion rotation) {
        var bullet = pool.Get(position, rotation);
        if (bullet != null) {
            bullet.SetPool(pool);
        }
    }
    
    void OnDestroy() {
        pool?.Clear();
    }
}