Unity flocking系统基于Time.time控制布尔值切换粒子行为失效问题

我是C#开发初学者，当前在Unity引擎中开发flocking集群系统，项目包含两个核心脚本：

• FlockTest：负责整体集群的全局管理
• FlockParticleBehaviour：负责单个集群粒子的行为逻辑实现

参考公开教程实现基础逻辑后，通过FlockTest脚本中定义的公开布尔值，即可控制FlockParticleBehaviour脚本中的目标追寻行为。在编辑器Play模式下，手动切换Inspector面板中的对应布尔选框，可以正常改变粒子的目标寻路行为。

目前需要实现基于运行时间自动切换上述布尔值的功能，用于后续接入AR会话场景，因此在FlockTest脚本的void Update()生命周期函数中添加了基于Time.time的if时间判断逻辑。运行测试后发现：Inspector面板中seekGoal、obedient、willful三个布尔值的选框可以按预期自动切换状态，但粒子的实际行为没有发生对应变化。
此前尝试使用Invoke方法实现自动切换逻辑也未生效：控制台无任何报错，对应布尔选框也不会发生状态切换。也考虑过使用协程实现该逻辑，但由于协程会涉及脚本的启停控制，不符合需求，因此不确定该方案是否适用。目前无法定位问题原因，不清楚如何让粒子正确响应Update函数中修改的布尔值，是否需要在粒子行为脚本的flock函数中做额外的引用关联处理？

布尔值本身已经正确修改，粒子行为不变化是代码逻辑存在三个硬伤：

1. 行为触发概率极低：flock()函数中给集群对齐、凝聚、自主行为都加了Random.Range(0,50) <=1的判断，相当于每帧只有2%的概率会更新粒子受力。手动切换选框时会长时间观察效果，能等到概率触发的行为变化；自动切状态时，2%的帧更新率会让状态切换后的行为延迟数秒才出现，肉眼感知上就像完全没生效。
2. 力残留问题：currentForce是类成员变量，当状态从obedient=true切到willful=true时，如果没有命中那2%的随机更新概率，粒子会一直沿用切换前计算好的currentForce，不会清零也不会重新计算，自然不会立刻切换行为。
3. 时间判断逻辑存在漏帧风险：直接用(int)Time.time == 3f做判断，如果游戏卡顿导致某一帧从2.9s直接跳到3.1s，虽然强转后值还是3能触发，但如果卡到4.0s就会直接跳过判断节点，永远不触发状态切换。Invoke不生效一般是方法名拼写错误、调用时机不对导致的，和变量传递无关。
4. 协程完全适配需求：协程绑定在挂载脚本的GameObject上，只要不主动禁用脚本、不销毁物体，协程就会正常运行，不存在额外的启停问题，反而比每帧跑Update判断时间更省性能。

1. 修复FlockTest脚本 #

优化时间判断逻辑，缓存组件引用减少性能开销，优先用协程实现自动状态切换：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class FlockTest : MonoBehaviour
{
    public GameObject[] particles;
    public GameObject particlePrefab;
    public int particleCount = 10;
    public Vector3 range = new Vector3(5,5,5);
    public Vector3 innerLimit = new Vector3(1,1,1);

    public bool seekGoal = true;
    public bool obedient = true;
    public bool willful = false;

    [Range(0, 200)]
    public int neighbourDistance =50;

    [Range(0,2)]
    public float maxForce = 0.5f;

    [Range(0,5)]
    public float maxvelocity = 2.0f;

    // 状态标记，避免重复触发赋值
    private int _currentStateStage = 0;

    void Start()
    {
        particles = new GameObject[particleCount];
        for(int i = 0; i < particleCount; i++)
        {
            Vector3 particlePos = new Vector3(Random.Range(-range.x, range.x), Random.Range(-range.y, range.y), Random.Range(-range.z, range.z));
            particles[i] = Instantiate(particlePrefab, this.transform.position + particlePos, Quaternion.identity);
            // 直接传递FlockTest组件引用，避免粒子脚本反复GetComponent
            particles[i].GetComponent<FlockParticleBehaviour>().manager = this;
        }
        // 启动协程自动切换状态
        StartCoroutine(AutoSwitchState());
    }

    IEnumerator AutoSwitchState()
    {
        // 初始状态维持3秒
        yield return new WaitForSeconds(3f);
        seekGoal = false;
        obedient = false;
        willful = true;
        _currentStateStage = 1;
        // 第一阶段状态维持3秒
        yield return new WaitForSeconds(3f);
        seekGoal = true;
        obedient = true;
        willful = false;
        _currentStateStage = 2;
        // 需要循环切换可在此处添加循环逻辑
    }

    // 不想用协程就用以下Update写法，彻底避免漏帧
    // void Update()
    // {
    //     int runTime = Mathf.FloorToInt(Time.time);
    //     if (_currentStateStage == 0 && runTime >=3)
    //     {
    //         seekGoal = false;
    //         obedient = false;
    //         willful = true;
    //         _currentStateStage =1;
    //     }
    //     if (_currentStateStage ==1 && runTime >=6)
    //     {
    //         seekGoal = true;
    //         obedient = true;
    //         willful = false;
    //         _currentStateStage =2;
    //     }
    // }
}

2. 修复FlockParticleBehaviour脚本 #

调整manager引用类型，修复力残留问题，把行为触发概率调整到合理区间：

using System.Collections.Generic;
using UnityEngine;

public class FlockParticleBehaviour : MonoBehaviour
{
    // 直接存储FlockTest组件引用，不需要存GameObject
    public FlockTest manager;
    public Vector3 location = Vector3.zero;
    public Vector3 velocity;
    Vector3 goalPos = Vector3.zero;
    Vector3 currentForce;
    private Rigidbody _rb;

    void Start()
    {
        _rb = GetComponent<Rigidbody>();
        velocity = new Vector3(Random.Range(0.01f, 0.1f), Random.Range(0.01f, 0.1f), Random.Range(0.01f, 0.1f));
        location = transform.position;
    }

    Vector3 seek(Vector3 target)
    {
        return(target - location);
    }

    void applyForce(Vector3 f)
    {
        Vector3 force = f;
        if(force.magnitude > manager.maxForce)
        {
            force = force.normalized * manager.maxForce;
        }
        _rb.AddForce(force);

        if(_rb.velocity.magnitude > manager.maxvelocity)
        {
            _rb.velocity = _rb.velocity.normalized * manager.maxvelocity;
        }
        Debug.DrawRay(transform.position, force, Color.white);
    }

    Vector3 align()
    {
        float neighbourdist = manager.neighbourDistance;
        Vector3 sum = Vector3.zero;
        int count = 0;
        foreach (GameObject other in manager.particles)
        {
            if(other == gameObject) continue;
            FlockParticleBehaviour otherBh = other.GetComponent<FlockParticleBehaviour>();
            float d = Vector3.Distance(location, otherBh.location);
            if (d < neighbourdist) {
                sum += otherBh.velocity;
                count++;
            }
        }
        if (count >0)
        {
            sum /= count;
            Vector3 steer = sum - velocity;
            return steer;
        }
        return Vector3.zero;
    }

    Vector3 cohesion()
    {
        float neighbourdist = manager.neighbourDistance;
        Vector3 sum = Vector3.zero;
        int count = 0;
        foreach (GameObject other in manager.particles)
        {
            if(other == gameObject) continue;
            FlockParticleBehaviour otherBh = other.GetComponent<FlockParticleBehaviour>();
            float d = Vector3.Distance(location, otherBh.location);
            if(d < neighbourdist)
            {
                sum += otherBh.location;
                count++;
            }
        }
        if (count > 0)
        {
            sum /= count;
            return seek(sum);
        }
        return Vector3.zero;
    }

    void flock()
    {
        location = transform.position;
        velocity = _rb.velocity;
        // 每帧重置受力，避免旧状态的力残留
        currentForce = Vector3.zero;

        if(manager.obedient)
        {
            Vector3 ali = align();
            Vector3 coh = cohesion();
            if(manager.seekGoal)
            {
                Vector3 gl = seek(goalPos);
                currentForce = gl + ali + coh;
            }
            else
            {
                currentForce = ali + coh;
            }
            currentForce = currentForce.normalized;
        }

        if(manager.willful)
        {
            // 自主行为设置10%概率随机转向，平衡自然度和响应速度
            if(Random.Range(0,10) < 1)
            {
                currentForce = new Vector3(Random.Range(-0.1f, 0.1f), Random.Range(-0.1f, 0.1f),Random.Range(-0.1f, 0.1f));
            }
        }
        applyForce(currentForce);
    }

    void Update()
    {
        goalPos = manager.transform.position;
        flock();
    }
}

修改后如果效果仍不符合预期，优先检查两项配置：

• 所有粒子预制体上都挂载了Rigidbody组件，且没有勾选Is Kinematic选项
• 两个脚本的Script Execution Order保持默认即可，不需要额外调整优先级

内容的提问来源于stack exchange，提问作者Delayne Rutter