群组行为是指多个对象组队同时行进的情况，我们可以坐下来，告诉每一个对象它该如何移动，但这样做的工作量太大。取而代之的是，我们去创建一个群组的领导，让它来为我们做这些，
这样我们所要做的就只是设置一些规则，然后群组中的boid就会自行组队。在本章中，我们将学习如何在unity3d中实现这种群组行为。
每个boid都可以应用一下三个基本的规则：
分离（seperation）：群组中的每个个体都与相邻个体保持一定距离
列队（alignment）：群组以相同速度，向相同方向移动
凝聚（cohesion）：群组中心保持最小距离
在本节中我们将创建自己的场景，场景里会有一群对象，并使用C#实现群组行为。有两个主要的组成部分：每个boid行为，以及维持并领导整个群组的主要控制者。我们的场景层级如图，在一个名为UnityFlockController的控制器下面有一些boid实体----UnityFlock。每一个UnityFlock实体都是一个boid对象，它们会引用其父对象UnityFlockController实体作为它们的领导者。UnityFlockController将会在到达目标位置后，随机的更新下一个目标位置。UnityFlock是一个预制体，这个预制体仅仅是一个立方体网格，并拥有UnityFlock脚本。我们可以使用任何更有意思的其他的网格标识这个预制体，比如小鸟。
个体行为
boid是Craig Reynold创造的术语，用以表示类似小鸟这样的对象。我们将使用这个术语描述群组中的每个个体对象。UnityFlock这个脚本控制群组中每一个boid的行为。
using UnityEngine;
using System.Collections;
public class UnityFlock : MonoBehaviour {
public float minSpeed = 20;//最小移动速度
public float turnSpeed = 20;//旋转速度
public float randomFreq = 20;//用来确定更新randomPush变量的次数
public float randomForce = 20;//这个力产生出一个随机增长和降低的速度，并使得群组的移动看上去更加真实
//alignment variables列队变量
public float toOriginForce = 50;//用这个来保持所有boid在一个范围内，并与群组的原点保持一定距离
public float toOriginRange = 100;//群组扩展的程度
public float gravity = 2;
//seperation variables分离变量
public float avoidanceRadius = 50;
public float avoidanceForce = 20;//这两个变量可以让每个boid个体之间保持最小距离
//cohesion variables凝聚变量，这两个变量可用来与群组的领导者或群组的原点保持最小距离。
public float followVelocity = 4;
public float followRadius = 40;
//这些变量控制了boid的移动
private Transform origin;//设为父对象，以控制整个群组中的对象。
private Vector3 velocity;
private Vector3 normalizeedVelocity;
private Vector3 randomPush;//更新基于randomFore的值
private Vector3 originPush;
//以下两个变量存储相邻boid的信息，当前boid需要知道群组中其他boid的信息
private Transform[] objects;
private UnityFlock[] otherFlocks;
private Transform transformComponent;
/*
*/
void Start () {
randomFreq = 1.0f / randomFreq;
//将父类指定为origin
origin = transform.parent;
//Flock transform
transformComponent = transform;
//Temporary components临时
Component[] tempFlocks = null;
//Get all the unity flock omponents from the parent transform in the group
if (transform.parent )
{
tempFlocks = transform.parent.GetComponentsInChildren<UnityFlock>();
}
//Assign and store all the flock objects in this group
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];
}
//Null Parent as the flok leader will be UnityFlockController object
transform.parent = null;
//Calculate random push depends on the random frequency provided
StartCoroutine(UpdateRandom());
}
IEnumerator UpdateRandom()
{
while (true)
{
randomPush = Random.insideUnitSphere * randomForce;
yield return new WaitForSeconds(randomFreq + Random.Range(-randomFreq / 2.0f, randomFreq / 2.0f));
}
}
void Update () {
//internal variables
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 = transformComponent.position;
Vector3 forceV;
Vector3 toAvg;
Vector3 wantedVel;
for (int i = 0; i < objects.Length; i++)
{
Transform transform = objects[i];
if (transform != transformComponent)
{
Vector3 otherPosition = transform.position;
//Average position to calculate cohesion
avgPosition += otherPosition;
count++;
//Directional vector from other flock to this flock
forceV = myPosition - otherPosition;
//Magnitude of that diretional vector(length)
d = forceV.magnitude;
//Add push value if the magnitude,the length of the vetor,is less than followRadius to the leader
if (d < followRadius)
{
//calculate the velocity,the speed of the object,based current magnitude is less than the specified avoidance radius
if (d < avoidanceRadius)
{
f = 1.0f - (d / avoidanceRadius);
if (d > 0)
{
avgVelocity += (forceV / d) * f * avoidanceForce;
}
}
//just keep the current distance with the leader
f = d / followRadius;
UnityFlock otherSealgull = otherFlocks[i];
//we normalize the otherSealgull veloity vector to get the direction of movement,then wo set a new veloity
avgVelocity += otherSealgull.normalizeedVelocity * f * followVelocity;
}
}
}
//上述代码实现了分离规则，首先，检查当前boid与其他boid之间的距离，并相应的更新速度，接下来，用当前速度除以群组中的boid的数目，计算出群组的平均速度
if (count > 0)
{
//Calculate the aveage flock veloity(Alignment)
avgVelocity /= count;
//Calculate Center value of the flock（Cohesion)
toAvg = (avgPosition / count) - myPosition;
}
else
{
toAvg = Vector3.zero;
}
//Directional Vector to the leader
forceV = origin.position - myPosition;
d = forceV.magnitude;
f = d / toOriginRange;
//Calculate the velocity of the flok to the leader
if (d > 0)
{
originPush = (forceV / d) * f * toOriginForce;
}
if (speed < minSpeed && speed > 0)
{
velocity = (velocity / speed) * minSpeed;
}
wantedVel = velocity;
//Calculate final velocity
wantedVel -= wantedVel * Time.deltaTime;
wantedVel += randomPush * Time.deltaTime;
wantedVel += originPush * Time.deltaTime;
wantedVel += avgVelocity * Time.deltaTime;
wantedVel += toAvg.normalized * gravity * Time.deltaTime;
//Final Velocity to rotate the flock into
velocity = Vector3.RotateTowards(velocity, wantedVel, turnSpeed * Time.deltaTime, 100.0f);
transformComponent.rotation = Quaternion.LookRotation(velocity);
transformComponent.Translate(velocity * Time.deltaTime, Space.World);
normalizeedVelocity = velocity.normalized;
}
}
