游戲AI之群組行為

群組行為指的是多個對象組隊同時進行的情況。每個boid需滿足分離，隊列，凝聚三個基本的規則。

分離：群組中的每個個體都與相鄰的個體保持一定的距離。

隊列：群組以相同的速度，向相同的方向移動。

凝聚：與群組的中心保持最小距離。

參見：http://www.red3d.com/cwr/boids/

結構：

控制器：即頭鳥下有controller類來控制自身的移動。

個體成員：單獨的個體，通過引用控制器的位置信息來產生群組跟隨的效果。

群組中的個體：

using UnityEngine;
using System.Collections;


/// <summary>
/// 該類是對群體中的每個個體行為的約束，即單個的鳥
/// </summary>
public class UnityFlock : MonoBehaviour
{

    //最小速度，轉向速度，隨機頻率，隨機力
    public float minSpeed = 20.0f;
    public float turnSpeed = 20.0f;
    public float randomFreq = 20.0f;
    public float randomForce = 20.0f;

    //隊列屬性 ：向心力，向心區間，吸引力
    public float toOriginForce = 50.0f;
    public float toOriginRange = 100.0f;

    public float gravity = 2.0f;

    //分離屬性：規避力，規避半徑
    public float avoidanceForce = 20.0f;
    public float avoidanceRadius = 50.0f;
    
    //凝聚屬性：追隨速度，追隨半徑（相對於領導者即頭鳥）
    public float followVelocity = 4.0f;
    public float followRadius = 40.0f;


    //控制單個個體運動的屬性：父對象即頭鳥，速度，歸一化速度，隨機推力，父對象的推力。。。
    private Transform origin;
    private Vector3 velocity;
    private Vector3 normalizedVelicity;
    private Vector3 randomPush;
    private Vector3 originPush;
    private Transform[] objects;
    private UnityFlock[] otherFlocks;//其他個體集合
    private Transform transformCompont;



    // Use this for initialization
    void Start ()
    {
        randomFreq = 1.0f/randomFreq;//獲取隨機變化的頻率
        //設置父節點為origin
        origin = transform.parent;

        transformCompont = transform;

        //臨時組件數組
        Component[] tempFlocks = null;

        if (transform.parent)
        {
            tempFlocks = transform.parent.GetComponentsInChildren<UnityFlock>();
        }

        objects=new Transform[tempFlocks.Length];
        otherFlocks=new UnityFlock[tempFlocks.Length];

        //將群體的位置信息和群體加載到數組
        for (int i = 0; i < tempFlocks.Length; i++)
        {
            objects[i] = tempFlocks[i].transform;
            otherFlocks[i] = (UnityFlock)tempFlocks[i];
        }

        transform.parent = null;

        StartCoroutine(UpdateRandom());
    }

    //基於randomFreq的頻率來更新randompush的頻率
    IEnumerator UpdateRandom()
    {
        while (true)
        {
            randomPush = Random.insideUnitSphere*randomForce;//Random.insideUnitSphere隨機返回單位球體類一點坐標，配合隨機力度來跟新randomPush
            yield return new WaitForSeconds(randomFreq+Random.Range(-randomFreq/2,randomFreq/2));//依據隨機頻率在一定時間分為類變換randomPush
        }
    }

    // Update is called once per frame
    void Update ()
    {
        float speed = velocity.magnitude;
        Vector3 avgVelocity = Vector3.zero;
        Vector3 avgPosition = Vector3.zero;
        float count = 0;
        float f = 0.0f;
        float d = 0.0f;
        Vector3 myPosition = transformCompont.position;
        Vector3 forceV;
        Vector3 toAvg;
        Vector3 wantedVel;

        for (int i = 0; i < objects.Length; i++)
        {
            Transform transform = objects[i];
            if (transform != transformCompont)
            {
                Vector3 otherPositon = transform.position;

                //平均位置來計算聚合
                avgPosition += otherPositon;
                count++;

                //從其他群體到這個的向量
                forceV = myPosition - otherPositon;

                //上面向量的長度
                d = forceV.magnitude;

                //如果向量長度比規避半徑小的話，則加大推力
                if (d < followRadius)
                {
                    //如果當前的向量長度小於規定的逃離半徑的話，則基於 逃離半徑計算對象的速度
                    if (d > 0)
                    {
                         f = 1.0f - (d/avoidanceRadius);
                        avgVelocity += (forceV / d) * f * avoidanceForce;
                        //向量除以它的模得到自己的單位向量
                    }

                }

                //保持與頭兒的距離
                f = d/followRadius;
                UnityFlock otherSealgull = otherFlocks[i];

                //標准化otherSealgul的速度來獲取移動的方向，接下來設置一個新的速度
                avgVelocity += otherSealgull.normalizedVelicity * f *followVelocity;

            }
        }

        if (count > 0)
        {
            //得到平均速度
            avgVelocity /= count;
            //獲得平均位置與對象間的向量
            toAvg = (avgPosition/count) - myPosition;
        }
        else
        {
            toAvg = Vector3.zero;
        }

        //
        forceV = origin.position - myPosition;
        d = forceV.magnitude;
        f = d/toOriginRange;
        //
        if (d > 0)
            originPush = (forceV/d)*f*toOriginForce;
        if (speed < minSpeed && speed > 0)
            velocity = (velocity/speed)*minSpeed;

        wantedVel = velocity;

        //最終速度
        wantedVel -= wantedVel*Time.deltaTime;
        wantedVel += randomPush*Time.deltaTime;
        wantedVel += originPush*Time.deltaTime;
        wantedVel += avgVelocity*Time.deltaTime;
        wantedVel += toAvg.normalized*gravity*Time.deltaTime;

        //調整速度使之轉向最終速度
        velocity = Vector3.RotateTowards(velocity, wantedVel,turnSpeed*Time.deltaTime, 100.00f);

        transformCompont.rotation = Quaternion.LookRotation(velocity);

        //移動對象
        transformCompont.Translate(velocity*Time.deltaTime,Space.World);

        //跟新標准化向量的引用
        normalizedVelicity = velocity.normalized;
    }



}

群組控制器（頭鳥）：

using UnityEngine;
using System.Collections;

/// <summary>
/// 頭鳥決定飛行的整體方向，在unityflock中被origin引用
/// </summary>
public class UnityFlockController : MonoBehaviour
{

    public Vector3 offset;//偏移
    public Vector3 bound;//范圍
    public float speed = 100.0f;

    private Vector3 initialPosition;
    private Vector3 nextMovementPoint;

    //
    
    // Use this for initialization
    void Start ()
    {
        initialPosition = transform.position;
        CalculateNextMovementPoint();
    }
    
    // Update is called once per frame
    void Update () {
        transform.Translate(Vector3.forward*speed*Time.deltaTime);
        transform.rotation=Quaternion.Slerp(transform.rotation,Quaternion.LookRotation(nextMovementPoint-transform.position),1.0f*Time.deltaTime );//調整飛行角度

        if(Vector3.Distance(nextMovementPoint,transform.position)<=10.0f)
        {
                    CalculateNextMovementPoint();
        }

    }

    void CalculateNextMovementPoint()
    {
        float posx = Random.Range(initialPosition.x - bound.x, initialPosition.x + bound.x);
        float posy = Random.Range(initialPosition.y - bound.y, initialPosition.y + bound.y);
        float posz = Random.Range(initialPosition.z - bound.z, initialPosition.z + bound.z);

        nextMovementPoint = initialPosition + new Vector3(posx, posy, posz);
    }
}

 

 

效果：