•  使用适当的 Display Object
  * Shape – 没有交互（占内存少）
  * Sprite – 有交互（占内存多）
  * MovieClip – 有时间线（占内存更多）
• 尽可能重用对象，而不要重新创建
• 强制类型转换 int(exp) 要比 Math.floor() 和 Math.ceil() 快很多
• 使用对象池技术重用对象
• 释放内存 – 将所有对象的引用设置为 null
• 尽可能重用 BitmapData
• Callback 要比 event 快而且消耗更少的内存

2. 减少 CPU 使用率

• 即便将一个 Display Object 从 stage 上移除了( removeChild ) 甚至是已经将它的引用设置为 null，它依然有可能在消耗 CPU。所以要在其移出 display list 时将其完全停下来（比如 mc.stop() ）。
• 卸载从外部装载的内容时，使用loader.unloadAndStop()，而不要使用 loader.unload()。
• 尽可能禁用鼠标交互。obj.mouseEnabled = false; obj.mouseChildren = false;
• Timer 在某些情况下比 ENTER_FRAME 要好。
• 减少 tweening 的使用。

3. ActionScript 性能

• 尽可能使用 Vector 替代 Array。固定长度的 Vector 更快。( Vector 可以这样初始化：var coords:Vector.<Number> = Vector.<Number>([132, 20, 46, 254, 244, 100, 20, 98, 218, 254]);)
• 新的 drawing API 更快，它们是：drawPath, drawGraphicsData, drawTriangles。
• 使用 setVector() 方法来处理像素。
• 使用 setPixel() 和 setPixel32 方法时，要配合使用 lock() 和 unlock() 方法。
• 使用 TextField 时，appendText() 方法比 += 操作符要快。
• 尽可能在避免在循环内更新 TextField。
• 尽可能少使用方括号操作符访问 Vector 或 Array 元素，可以利用一个临时变量来操作。
• 尽量将代码内嵌，避免过多的函数调用。（比如用 value > 0 ? value : -value; 来代替 Math.abs()）
• 代码量过大也会造成性能的降低。尽量少使用大型第三方库(Flex, TLF)。
• 避免在循环内使用取值表达式（myArray.length）。用临时局部变量来操作。
• 更多优化技巧参考：http://www.rozengain.com/blog/2007/05/01/some-actionscript-30-optimizations/

4. 渲染性能

• 尽可能避免使用 alpha 参数。
• 适当的使用 cacheAsBitmap 可以大幅提高性能。（对于变化少的矢量元件）
• 针对每个子元件使用 cacheAsBitmap 而不是针对父元件使用。
• 使用 TextLine 处理静态文本比 TextField 快而且使用更少的内存。
• 使用 cacheAsBitmap 和 opaqueBackground 参数可以改进渲染性能（包含 TextField ）。

图 2-7 追赶行为先计算车子将要到哪儿再寻找过去

同样，这种方法只一粗略的计算，因为一切都在运动中。但是它比寻找更加精确就已经不错了。它也是相当简单和快速的。如果你愿意，这个方法还有更精确（更复杂）的算法可以去研究和实现。但是这里至少是我们的起点。
    现在开始行动吧。这次我们将创建三辆机车。一个是简单的运动机车（Vehicle）作为目标对象。其它两个都是转向机车（SteeredVehicle），一个寻找目标而另一个追赶目标。如果一切正常，追赶者应该胜出，这要归功于其算法优势。大家可以在本书站点下载 PursueTest.as 文件：
package
{
 import com.foed.SteeredVehicle;
 import com.foed.Vector2D;
 import com.foed.Vehicle;
 
 import flash.display.Sprite;
 import flash.display.StageAlign;
 import flash.display.StageScaleMode;
 import flash.events.Event;

 public class PursueTest extends Sprite
 {
  private var _seeker:SteeredVehicle;
  private var _pursuer:SteeredVehicle;
  private var _target:Vehicle;
  
  public function PursueTest()
  {
   stage.align = StageAlign.TOP_LEFT;
   stage.scaleMode = StageScaleMode.NO_SCALE;
   
   _seeker = new SteeredVehicle();
   _seeker.x = 400;
   addChild(_seeker);
   
   _pursuer = new SteeredVehicle();
   _pursuer.x = 400;
   addChild(_pursuer);
   
   _target = new Vehicle();
   _target.position = new Vector2D(200, 300);
   _target.velocity.length = 15;
   addChild(_target);
   
   addEventListener(Event.ENTER_FRAME, onEnterFrame);
  }
  
  private function onEnterFrame(event:Event):void
  {
   _seeker.seek(_target.position);
   _seeker.update();
   
   _pursuer.pursue(_target);
   _pursuer.update();
   
   _target.update();
  }
 }
}
注意两个转向机车在同一个位置起跑，寻找者很快就移动到目标点，而追赶者是迎头赶上并拦截目标。
    关于这个实验要明确一点——有很多参数和数值会影响效果。接下来是逃离行为。

逃离（Evade）行为
你可能已经猜到了，逃离和追赶是截然相反的。就向追赶与寻找非常相似一样，躲避和逃离也非常相似并且会用到前者。
    实际上，逃离会预测车子将会去哪以便将来更好地回避并直接远离这一点。至此所有原则都在追赶行为中讨论过了。实际上，除了最后一行调用的是 flee 而非 seek，其它地方和追赶行为完全相同：
public function evade(target:Vehicle):void
{
 var lookAheadTime:Number = position.dist(target.position) / _maxSpeed;
 var predictedTarget:Vector2D =
 target.position.subtract(target.velocity.multiply(lookAheadTime));
 flee(predictedTarget);
}
无需更多的解释。下面是一个快捷的 pursue 和 evade 方法的测试，见 PursueEvadeTest.as 文件：
package
{
 import com.foed.SteeredVehicle;
 import com.foed.Vector2D;
 import com.foed.Vehicle;
 
 import flash.display.Sprite;
 import flash.display.StageAlign;
 import flash.display.StageScaleMode;
 import flash.events.Event;

 public class PursueEvadeTest extends Sprite
 {
  private var _pursuer:SteeredVehicle;
  private var _evader:SteeredVehicle;
  
  public function PursueEvadeTest()
  {
   stage.align = StageAlign.TOP_LEFT;
   stage.scaleMode = StageScaleMode.NO_SCALE;
   
   _pursuer = new SteeredVehicle();
   _pursuer.position = new Vector2D(200, 200);
   _pursuer.edgeBehavior = Vehicle.BOUNCE;
   addChild(_pursuer);
   
   _evader = new SteeredVehicle();
   _evader.position = new Vector2D(400, 300);
   _evader.edgeBehavior = Vehicle.BOUNCE;
   addChild(_evader);
   
   addEventListener(Event.ENTER_FRAME, onEnterFrame);
  }
  
  private function onEnterFrame(event:Event):void
  {
   _pursuer.pursue(_evader);
   _evader.evade(_pursuer);
   _pursuer.update();
   _evader.update();
  }
 }
}
我们看到，这个例子和 SeekFleeTest1 效果基本相同，现在用的是追赶和逃离行为。因为两个车子都用了更高级的方法，两者都没有高低之分，所以很难看出它们和 seek/flee 的测试有什么不同。然而，玩过一会儿，替换一些方法，看看你会发现什么。下面，我们从 seek/flee 这类的行为中走出，进入到更加随机的漫游行为。

漫游（Wander）行为
漫游行为就像它的名字一样。角色在屏幕上漫无目的的游荡。在游戏或模拟运动中通常用作搜寻或觅食——或者只是漫游。
    漫游行为不像听起来那么简单，实现起来可能会有点儿复杂。你可以简单地使用一些随机行为，如布朗运动，但是那会让角色看起来有些神经质或者不平稳。我们期望的是更加平滑和自然的效果。通常的做法是在角色的周围想象有一个圆，选择圆上的任意一点作为目标点。在每一帧或每次更新时，角色向这个点移动。由于目标点总是在假想的圆上，因此计算出的转向力永远不会有太大的变化。这个行为如图 2-8 所示。

图 2-8 漫游者用距离（distance）、半径（radius）和偏移量（offset）计算转向力

我们可以改变某些参数得到不同漫游范围：如圆的大小，圆和角色的距离以及每帧可以移动多少个随机点。
下面是 wander 方法：
public function wander():void
{
 var center:Vector2D = velocity.clone().normalize().multiply(_wanderDistance);
 var offset:Vector2D = new Vector2D(0);
 offset.length = _wanderRadius;
 offset.angle = _wanderAngle;
 _wanderAngle += Math.random() * _wanderRange - _wanderRange * .5;
 var force:Vector2D = center.add(offset);
 _steeringForce = _steeringForce.add(force);
}
首先我们找到了圆心。速度向量位于机车的正前方。通过标准化该向量并乘以 _wanderDistance 得到圆的位置。从那里，添加另一个叫 offset 的向量，随机指向圆上的某一点。因此 offset 的长度就是 _wanderRadius，角度则是 _wanderAngle。然后，我们将在 _wanderRange 中随机变化 _wanderAngle 的值。圆心加上偏移（偏移）得到的向量就是这个行为的转向力。再将它加入到转向力中就完成了。

请注意以下是新加入到 SteeredVehicle 类中的变量。将它们定义在类的开始并初始化：
private var _wanderAngle:Number = 0;
private var _wanderDistance:Number = 10;
private var _wanderRadius:Number = 5;
private var _wanderRange:Number = 1;
然后我们提供一些访问方法，以便让可以在单独的机车上改变它们（_wanderAngle 是完全随机的无需具体指定）：
public function set wanderDistance(value:Number):void
{
 _wanderDistance = value;
}
public function get wanderDistance():Number
{
 return _wanderDistance;
}

public function set wanderRadius(value:Number):void
{
 _wanderRadius = value;
}
public function get wanderRadius():Number
{
 return _wanderRadius;
}

public function set wanderRange(value:Number):void
{
 _wanderRange = value;
}
public function get wanderRange():Number
{
 return _wanderRange;
}
最后，看看它运行起来怎么样，见 WanderTest.as 文件：
package
{
 import com.foed.SteeredVehicle;
 import com.foed.Vector2D;
 
 import flash.display.Sprite;
 import flash.display.StageAlign;
 import flash.display.StageScaleMode;
 import flash.events.Event;

 public class WanderTest extends Sprite
 {
  private var _vehicle:SteeredVehicle;
  
  public function WanderTest()
  {
   stage.align = StageAlign.TOP_LEFT;
   stage.scaleMode = StageScaleMode.NO_SCALE;
   
   _vehicle = new SteeredVehicle();
   _vehicle.position = new Vector2D(200, 200);
   addChild(_vehicle);
   
   addEventListener(Event.ENTER_FRAME, onEnterFrame);
  }
  
  private function onEnterFrame(event:Event):void
  {
   _vehicle.wander();
   _vehicle.update();
  }
 }
}
你可以变换不同的 wander 变量看看它们的不同。还有别忘了试试其它属性（如 mass、maxSpeed、maxForce）对漫游有什么影响。你还可以重新试一下早前的 seek 和 pursue 测试让寻找者／追赶者去跟随一辆漫游的机车。
    东西越来越有趣了并且接下来会更棒。简单的行为我们已经都看过了。剩下的会更为复杂，先从对象回避开始。

对象回避（Object avoidance）
这个行为与前面看到的都不一样，因为对象回避更为复杂而且似乎每个人都会给它一些不同的诠释——从简单到极度难懂的解决方法。因为这个行为没有一个完全统一的标准，我要带大家以非常基本的实现作为起点，同时鼓励大家不断进步。
    对象回避（object avoidance）指有些东西挡在机车的轨道上，而车子必需转向另一条路以免碰撞。所以它和碰撞检测似乎有些关系，只不过现在把检测放在了预测阶段：“以我当前的速度前进，我将会撞到那个物体”。
    一旦预测到会发生碰撞，那么就需要做一些智能的动作确保不会发生碰撞。简单的做法你可以只是停下来或转个身，但是别忘了多种行为可能会交织在一起。如果你正在试图躲避或逃离追击者，那么当你在路径上看到一棵树的时候停下或向后转好像不是非常聪明的选择。理想的是你应该做一些必要的动作来躲避障碍同时继续躲避或逃离。而追击者本身也需要躲避障碍同时继续追击。
    近一步讲，你可以想象离你要躲避的目标越近，你越要更多地改变路径。假如你穿过沙漠看到几英里处有一座金字塔，你可以转一两度弯，然后径直向前。但是如果你到了金字塔跟前，那么你就需要转 90 度的弯才能躲过去。
    现在看到它是多么复杂了吧，知道为什么有很多不同的实现方法了吧。第一种简单做法也是有最多人实现过的，就是将障碍物看作圆（或在3D世界中看作球体）。障碍物实际上可能不是一个圆，但是如果你把它想成一个拥有半径的中心点，那么计算就会非常简单并且基本可以工作。请记住我们通常不寻求像素级的碰撞检测；只要知道障碍物的位置以及大小，就可以避开它了。下面就是这个用来表示障碍物的Circle（圆）类：
package com.foed
{
 import flash.display.Sprite;

 public class Circle extends Sprite
 {
  private var _radius:Number;
  private var _color:uint;
  
  public function Circle(radius:Number, color:uint = 0x000000)
  {
   _radius = radius;
   _color = color;
   graphics.lineStyle(0, _color);
   graphics.drawCircle(0, 0, _radius);
  }
  
  public function get radius():Number
  {
   return _radius;
  }
  
  public function get position():Vector2D
  {
   return new Vector2D(x, y);
  }
 }
}
这个类仅持有半径（radius）和颜色（color）属性，然后根据半径画圆。radius 和 position 都有各自的 getter 方法，分别获取半径和一个 Vector2D 对象。下面就来实现对象回避行为。
    由于通常要回避的对象会多于一个，因此 avoid（回避）方法持有一个圆的数组，循环它们，看看它们是否需要回避。如果是，则计算一个转向力完成这件事。代码变得相当复杂，因为有很多不同版本的对象回避行为，因此我仅给大家展示一个没有过多解释的例子。
    预测碰撞的代码基本是参照 AI for Game Developers 一书中例子，由 O'Reilly 公司的 David M. Bourg 和 Glenn Seemann 编写，不过相当简单。转向力是根据多种资源和思想以及一点我自己的想象混合计算出来的。我将让代码注释来解释这段代码（运行效果如图 2-9 所示）：
public function avoid(circles:Array):void
{
 for(var i:int = 0; i < circles.length; i++)
 {
  var circle:Circle = circles[i] as Circle;
  var heading:Vector2D = _velocity.clone().normalize();
  
  // 圆和机车间的向量
  var difference:Vector2D = circle.position.subtract(_position);
  var dotProd:Number = difference.dotProd(heading);
  
  // 如果圆在机车前面……
  if(dotProd > 0)
  {
   // 代表机车“触角”feeler 的向量
   var feeler:Vector2D = heading.multiply(_avoidDistance);
   // difference 向量在 feeler 上的映射
   var projection:Vector2D = heading.multiply(dotProd);
   // 圆和触角间的距离
   var dist:Number = projection.subtract(difference).length;
   
   // 如果触角和圆相交（算上缓冲），并且映射小于触角长度，
   // 则会发生碰撞，因此需要转向
   if(dist < circle.radius + _avoidBuffer &&
      projection.length < feeler.length)
   {
    // 计算一个正负 90 度的力
    var force:Vector2D = heading.multiply(_maxSpeed);
    force.angle += difference.sign(_velocity) * Math.PI / 2;
    
    // 根据到达圆的距离，增加或减少这个力
    force = force.multiply(1.0 - projection.length /
            feeler.length);
    
    // 加入到转向力
    _steeringForce = _steeringForce.add(force);
    
    // 刹车力
    _velocity = _velocity.multiply(projection.length / feeler.length);
   }
  }
 }
}

图 2-9 当碰撞发生的时候，就会应用转向力

注意这里有两个属性必需加到类中：
    private var _avoidDistance:Number = 300;
    private var _avoidBuffer:Number = 20;
回避距离（avoidDistance）是机车在多远的距离能看障碍物。回避缓冲（avoidBuffer）是机车经过障碍物并要躲避时自身与物体的距离。
    这段代码并不完美，但是还算不错没有让 CPU 负荷太高。大家可以直接用它也可以改进它或只是寥寥看一下。下面是一个实例，见 AvoidTest.as 文件：
package
{
 import com.foed.Circle;
 import com.foed.SteeredVehicle;
 import com.foed.Vector2D;
 import com.foed.Vehicle;
 
 import flash.display.Sprite;
 import flash.display.StageAlign;
 import flash.display.StageScaleMode;
 import flash.events.Event;

 public class AvoidTest extends Sprite
 {
  private var _vehicle:SteeredVehicle;
  private var _circles:Array;
  private var _numCircles:int = 10;
  
  public function AvoidTest()
  {
   stage.align = StageAlign.TOP_LEFT;
   stage.scaleMode = StageScaleMode.NO_SCALE;
   
   _vehicle = new SteeredVehicle();
   _vehicle.edgeBehavior = Vehicle.BOUNCE;
   addChild(_vehicle);
   
   _circles = new Array();
   for(var i:int = 0; i < _numCircles; i++)
   {
    var circle:Circle = new Circle(Math.random() * 50 + 50);
    circle.x = Math.random() * stage.stageWidth;
    circle.y = Math.random() * stage.stageHeight;
    addChild(circle);
    _circles.push(circle);
   }
   
   addEventListener(Event.ENTER_FRAME, onEnterFrame);
  }
  
  private function onEnterFrame(event:Event):void
  {
   _vehicle.wander();
   _vehicle.avoid(_circles);
   _vehicle.update();
  }
 }
}
这里创建一个圆的数组，当车子试图躲避圆的时候它会漫游开。这个实现相当简单，但是运行得不错。它可以处理漫游或直线运动，当寻找物体的同时又要躲避时，这种方法就有些粗糙了。不过这类行为会在第四章寻路中得到更好的解决。接下来，我们进入另一种行为：路径跟随。

路径跟随（Path following）
路径跟随和它的名字很像：车子沿预定路径行进。路径可以在地图或游戏世界中被图像化，而对转向行为而言，可以用一组航点（waypoint）来表示。在 ActionScript 3.0 的实现中，只需要一个 Vector2D 对象数组。
    实现策略惊人的简单。拿到第一个航点作为寻找目标。当机车在该点的一定范围内时，我们就认为它到达了该航点，然后向下一个移动。直至到达最后一个航点为止。你可以用一个循环路径，这样车子就会在到达最后一点时再从第一点重新开始。如图 2-10 所示。

图 2-10 寻找第一个航点。当距离足够近时寻找下一个……

类中需要新加两个属性：
    private var _pathIndex:int = 0;
    private var _pathThreshold:Number = 20;
然后让我们给这些属性提供访问器：
public function set pathIndex(value:int):void
{
 _pathIndex = value;
}
public function get pathIndex():int
{
 return _pathIndex;
}

public function set pathThreshold(value:Number):void
{
 _pathThreshold = value;
}
public function get pathThreshold():Number
{
 return _pathThreshold;
}
第一个访问器给 _pathIndex，它持有航点数组的索引。_pathThreshold 访问器定义距离航点多远时就认为该点“走完”了。

以下是具体的实现：
public function followPath(path:Array, loop:Boolean = false):void
{
 var wayPoint:Vector2D = path[_pathIndex];
 if(wayPoint == null) return;
 if(_position.dist(wayPoint) < _pathThreshold)
 {
  if(_pathIndex >= path.length - 1)
  {
   if(loop)
   {
    _pathIndex = 0;
   }
  }
  else
  {
   _pathIndex++;
  }
 }
 if(_pathIndex >= path.length - 1 && !loop)
 {
  arrive(wayPoint);
 }
 else
 {
  seek(wayPoint);
 }
}
这些判断语句有些混乱。首先，拿到航点数组中的第一个元素。如果它不是一个有效的 Vector2D 对象则直接 return。允许传入空数组。
    如果 Vector2D 对象有效，就判断它是否在 threshold（阈值）距离内。如果是，则判断它是不是最后一个航点。如果是，则循环到第一点。如果不是最后一个航点，移到下一个。写起来有点儿复杂，但如果你将航点一个个画在纸上然后顺着它们连成线，你会发现这真的很简单。
    现在，我们有了引导的航点。只需要运行 — seek( wayPoint) — 就能运行得很好了。不过我们还可以通过允许一种特殊情况让它变得更优雅一些：移动到路径的最后一个点时不 做循环，而是用到达行为替代寻找。这样就让机车缓动到最后一个航点而非前后乱跳。
    好了，介绍完了。我们需要一个可以运行的例子（PathTest.as 文件）：
package
{
 import com.foed.SteeredVehicle;
 import com.foed.Vector2D;
 
 import flash.display.Sprite;
 import flash.display.StageAlign;
 import flash.display.StageScaleMode;
 import flash.events.Event;
 import flash.events.MouseEvent;

 public class PathTest extends Sprite
 {
  private var _vehicle:SteeredVehicle;
  private var _path:Array;
  
  public function PathTest()
  {
   stage.align = StageAlign.TOP_LEFT;
   stage.scaleMode = StageScaleMode.NO_SCALE;
   
   _vehicle = new SteeredVehicle();
   addChild(_vehicle);
   
   _path = new Array();
   
   stage.addEventListener(MouseEvent.CLICK, onClick);
   addEventListener(Event.ENTER_FRAME, onEnterFrame);
  }
  
  private function onEnterFrame(event:Event):void
  {
   _vehicle.followPath(_path, true);
   _vehicle.update();
  }
  
  private function onClick(event:MouseEvent):void
  {
   graphics.lineStyle(0, 0, .25);
   if(_path.length == 0)
   {
    graphics.moveTo(mouseX, mouseY);
   }
   graphics.lineTo(mouseX, mouseY);
   
   graphics.drawCircle(mouseX, mouseY, 10);
   graphics.moveTo(mouseX, mouseY);
   _path.push(new Vector2D(mouseX, mouseY));
  }
 }
}
相当简单对吧。大部分代码是关于绘制路径的。这里有一个 _path 数组并且车子在 onEnterFrame 方法中设置为跟随路径。起初，它是一个没有航点的空数组，所以车子不会动。
    我们每次点击鼠标就会在路径上创建一个新的航点。同时 onClick 方法只是让路径可以显示出来。
    一旦你开始点击，车子就会开始沿你创建的路径前进。因为 loop 参数指定为 true，所以它会沿着路径绕圈。注意车子不是机械化的紧贴着路径走；它是自然的运动——温和地过度转弯和死角。通过改变 threshold 的值会影响转弯的效果。其它 SteeredVehicle 的属性，如 mass、maxSpeed、maxForce 也会影响转向行为。所以有很多数值可以调整以达到你想要的效果。
    路径跟随通常与寻路（第四章）结合使用。寻路关注的是两个点间的最佳路线。它要考虑到角色不能到达的区域以及地形的潜在因素如石子地面与平缓地面。寻路通常是基于网格的，结果通常是一个可以让角色移动到目标的网格数组。这个数组可以当作路径跟随转向行为的路径，这样可以让运动显得更自然。
    接下来，我们讨论最后一种行为，集群，它是三类子行为真正复杂的组合。

集群（Flocking）行为
说到集群行为就不得不提到 Craig Reynolds 和它的“boids”模拟系统。Reynolds 做了一项惊人工作将看似极为复杂过程转换成几种简单的行为。

说到鸟群，它有三个主要特性：
■ 首先，这些鸟基本都在一个区域内。如果其中一只移动过快远离了它的群落，它会很快回归群体。这就是凝聚（cohesion），如图 2-11 所示。

图 2-11 凝聚：寻找邻居位置的平均值

■ 然后，它又不喜欢离彼此太近，因此试图躲避相互碰撞。它们有私人空间的独立意识并开始防止跟别的鸟离得太近或者允许和另一只鸟离自己很近。这就是分离（separation），如图 2-12 所示。

图 2-12 分离：如果跟邻居太近，则离开

■ 最后，鸟群向大概一致的方向移动。是的，这里会有一点个别的变化，但是总体一致，这些鸟以它们的方向移动，最终鸟群汇成一条线。这就是队列（alignment），如图 2-13 所示。

图 2-13 队列：调整到邻居向量的平均值

    凝聚、分离、队列这三个行为构成了一个复杂的集群行为。
    当想到鸟群的复杂行为时，有的人势必会猜想需要对鸟群整体进行智能控制，或者假设每只鸟都有完全独立的意识。这些想法我都不反对，但是我要说当你开始理解这三种行为组成群落时，你会发现每只鸟不必都让大家知道，也不需要一个总体的“蜂巢”控制器。事实上，每只鸟只需要能看到当前临近的鸟。如果它开始接近它们，但又不是太近，则将自身的方向调整为临近鸟的方向，接下来这个神秘的集群行为就浮现在我们眼前了。
    虽然，技术上讲集群行为是由三个子行为组成的，但是这三个行为通常是一起使用的。我们一般不需要角色只展现一种或两种行为，所以这三个行为的代码将会写在一个方法里。这样实现起来也会更加高效，因为需要很多循环，如果将三件事都放在一个循环里完成就会更好。OK，下面就是这个方法：
public function flock(vehicles:Array):void
{
 var averageVelocity:Vector2D = _velocity.clone();
 var averagePosition:Vector2D = new Vector2D();
 var inSightCount:int = 0;
 for(var i:int = 0; i < vehicles.length; i++)
 {
  var vehicle:Vehicle = vehicles[i] as Vehicle;
  if(vehicle != this && inSight(vehicle))
  {
   averageVelocity = averageVelocity.add(vehicle.velocity);
   averagePosition = averagePosition.add(vehicle.position);
   if(tooClose(vehicle)) flee(vehicle.position);
   inSightCount++;
  }
 }
 if(inSightCount > 0)
 {
  averageVelocity = averageVelocity.divide(inSightCount);
  averagePosition = averagePosition.divide(inSightCount);
  seek(averagePosition);
  _steeringForce.add(averageVelocity.subtract(_velocity));
 }
}
首先，传入机车数组。策略是循环整个数组看哪一辆车子在当前车子的视野范围内，如果车子在视野内，则将它们的速度和位置加到一起。我们也记录有多少车子在视野内用以计算平均值。还要注意如果当前处理的车子就是自身，则略过。
    如果有车子靠得太近，就执行躲避（flee）行为远离它，即允许与它分道扬镳。
    当遍历过整个数组后，如果在视野范围内发现了机车，则计算位置和速度的平均值。我们寻找（seek）到平均位置并让转向力朝向平均速度。
    不是很困难，但是要注意有两个用到的方法目前还没有展示：inSight 和 tooClose：
public function inSight(vehicle:Vehicle):Boolean
{
 if(_position.dist(vehicle.position) > _inSightDist) return false;
 var heading:Vector2D = _velocity.clone().normalize();
 var difference:Vector2D = vehicle.position.subtract(_position);
 var dotProd:Number = difference.dotProd(heading);
 
 if(dotProd < 0) return false;
 return true;
}

public function tooClose(vehicle:Vehicle):Boolean
{
 return _position.dist(vehicle.position) < _tooCloseDist;
}
inSight 方法决定一辆机车是否可以看到另一辆。要做到这一点，首先判断那辆机车是否在某个范围内。如果不是则返回 false。然后做一些新奇的向量数学运算来判断机车是否在其前面或后面。如果另一辆机车在前面，则可以看到它；如果在后面则看不到它。这其实是一个相当硬性的实现，因为它只允许 180 度的视野。这个实例能够很好表达我们的意图，但是如果想要改良这个行为可以从改变不同的视野方面入手。一个较窄的视野意味着角色只能看到正前方而很少看到两旁的物体。一个较宽的视野意味着角色可能看到身后的东西。这些视野的变化会导致不同形态的集群。
    下面是 tooClose 方法，如果机车在某个特定范围内则返回 true；否则返回 false。

我们看到这两个方法需要依赖两个类变量。并且还要加为它们加两个访问器：
private var _inSightDist:Number = 200;
private var _tooCloseDist:Number = 60;

public function set inSightDist(value:Number):void
{
 _inSightDist = value;
}
public function get inSightDist():Number
{
 return _inSightDist;
}

public function set tooCloseDist(value:Number):void
{
 _tooCloseDist = value;
}
public function get tooCloseDist():Number
{
 return _tooCloseDist;
}
最终，我们需要一个测试类（见 FlockTest.as 文件）：
package
{
 import com.foed.SteeredVehicle;
 import com.foed.Vector2D;
 import com.foed.Vehicle;
 
 import flash.display.Sprite;
 import flash.display.StageAlign;
 import flash.display.StageScaleMode;
 import flash.events.Event;

 public class FlockTest extends Sprite
 {
  private var _vehicles:Array;
  private var _numVehicles:int = 30;
  
  public function FlockTest()
  {
   stage.align = StageAlign.TOP_LEFT;
   stage.scaleMode = StageScaleMode.NO_SCALE;
   
   _vehicles = new Array();
   for(var i:int = 0; i < _numVehicles; i++)
   {
    var vehicle:SteeredVehicle = new SteeredVehicle();
    vehicle.position = new Vector2D(Math.random() * stage.stageWidth, Math.random() * stage.stageHeight);
    vehicle.velocity = new Vector2D(Math.random() * 20 - 10, Math.random() * 20 - 10);
    vehicle.edgeBehavior = Vehicle.BOUNCE;
    _vehicles.push(vehicle);
    addChild(vehicle);
   }
   addEventListener(Event.ENTER_FRAME, onEnterFrame);
  }
  
  private function onEnterFrame(event:Event):void
  {
   for(var i:int = 0; i < _numVehicles; i++)
   {
    _vehicles[i].flock(_vehicles);
    _vehicles[i].update();
   }
  }
 }
}
我们简单地创建了一群转向机车，将它们分散到舞台上，并加入数组中。每一帧，循环整个数组，让每一辆车执行集群（flock）行为，然后执行更新（update）。你会看到虽然每辆车子都是独立运动的，但是它们对周围是有意识的，并且是动态成组的。改变一下变量，车子数量，了解一下它是如何工作的。
    另一个可以改良的地方是数组的优化。目前每辆机车会判断整个数组，这样做效率会很差。你可以用双重循环或类似第一章介绍的基于网格的实现对其进行重构。然而，这可能需要将一些代码从 flock 方法中移出到主文档类或其它集群控制器类。我就把这个任务留给大家了。

总结
本章介绍了基本的转向行为，从简单的寻找和躲避到复杂的对象回避和集群行为。乐趣在于将这些行为结合起来创建出复杂的动力系统。同时，这一章只对这个主题做一个浅显的介绍。在网上和其它相关书籍中会有大量的关于转向行为的资料，通常隶属于人工智能。我希望本章至少能给大家一些启发并可以运用到你的 ActionScript 3.0 应用和游戏中。
    下一章讨论等角世界以及寻路，结合本章的转向行为（或许还有高级碰撞检测），我们就可以创建出自己大型的游戏。

图 2-2 运动中的机车

    对于 Vehicle 类的测试已经完成了。让我们进入更有趣的部分——转向行为，也就是本章的重点。

SteeredVehicle 类
    SteeredVehicle 类继承自 Vehicle 并增加了转向行为。每个行为都是 public 方法以便在每侦或每个定时间隔被访问用于施加某种转向力。通常在所有的转向力增加后再调用 update 方法。
    例如，如果我们想要创建一个简单的漫游机车，可以在 update 之前调用其 wander 方法：
private function onEnterFrame(event:Event):void
{
 _vehicle.wander();
 _vehicle.update();
}
这里是转向行为的工作方式：调用转向方法，计算转向力，是一种让机车顺时针或逆时针转向的力。如 seek 方法会计算足够让机车转到目标点的力。机车可能会受到多种转向行为的影响——可能在寻找目标的时候同时需要逃避或躲闪另一辆机车。这些力加杂一起。当最后调用 update 方法时，vehicle 计算出所有的转向力而后改变其自身速度（方向与速度）。
    这里是 SteeredVehicle 类的核心，除去了机车类已经有的行为代码（SteeredVehicle.as 可以从本书的网站下载）：
package com.foed
{
 import flash.display.Sprite;

 public class SteeredVehicle extends Vehicle
 {
  private var _maxForce:Number = 1;
  private var _steeringForce:Vector2D;
  
  public function SteeredVehicle()
  {
   _steeringForce = new Vector2D();
   super();
  }
  
  public function set maxForce(value:Number):void
  {
   _maxForce = value;
  }
  public function get maxForce():Number
  {
   return _maxForce;
  }
  
  override public function update():void
  {
   _steeringForce.truncate(_maxForce);
   _steeringForce = _steeringForce.divide(_mass);
   _velocity = _velocity.add(_steeringForce);
   _steeringForce = new Vector2D();
   super.update();
  }
 }
}
我们看到 _steeringForce 属性，一个 Vector2D 类型。这个属性记录所有行为的转向力（注意还有一个 _maxForce 属性）。在现实中我们不会看到机车或角色有“急转弯”现象，所以要限制每一个帧实际可能的转向力。通过 maxForce 的 getter/setter 方法对其进行访问。通过调整 maxForce 属性可以让机车急速转弯、快速移动、更加准确到达目标或者拐一个大弯。
    现在让我们跳到 update 方法。假设一个或多个转向行为被调用，_steeringForce 属性包含一个超级向量。update 方法首先截断 _steeringForce 使其不会大于最大的转向力。然后用 _steeringForce 除以机车的质量（mass）。在真实世界中，大车拥有较大的动量需要拐大弯，而小车转弯更快。转向力被加到当前机车的速度上，_steeringForce 变量重置为下一轮累加做准备。最后调用基类的 update 方法，完成所有的基本移动工作，该工作已经在 Vehicle 类中实现了。
    现在让我们看看行为的实现，从寻找（seek）开始。每一个行为都是 SteeredVehicle 类中的一个公共方法。某些行为则需要新的类变量或额外的方法来支持，并且必要的时候它们还要暴露出来。

Seek（寻找）行为
如前面描述的，寻找只是让机车移运动到指定点。方法如下：
public function seek(target:Vector2D):void
{
 var desiredVelocity:Vector2D = target.subtract(_position);
 desiredVelocity.normalize();
 desiredVelocity = desiredVelocity.multiply(_maxSpeed);
 var force:Vector2D = desiredVelocity.subtract(_velocity);
 _steeringForce = _steeringForce.add(force);
}
首先，计算出期望速度（desired velocity），即能让车子运动到目标点的确切速度。用机车的位置减去目标位置。意思就是“如果以这个方向，走这段距离，你就会到达想去的地方”。如图 2-3 所示。

图 2-3 以期望速度运动会立即到达目标点

当然，事情不总是如人所愿。有的时候可能你会发现更好的算法。这里我们将标准化（normalize）期望速度并乘以最大速度（maxSpeed）。这样仍会得出一个指向目标点的向量，而它的量与车子运动的最快速度相同，其含意是“你不能即刻到达那里，但要朝这个方向以最快速度运动，你就会很快到达”。
    期望速度有了；还要考虑车子自身已有的速度。用期望速度减去车子速度得到一个向量，意义是“将这个向量加入到当前速度，朝向正确的方向以最快速度前进”。
    这个向量就是转向力。别忘了在 update 方法中，让 _steeringForce 和 maxForce 做截断操作。所以我们不是全速前进到目的地，而是要在 _maxForce 和 _maxSpeed 的限制中找到最佳点。如图 2-4 所示。

图 2-4 最佳期望速度，以及改变当前速度所需的力

现在我们看一个寻找行为的示例：
package
{
 import com.foed.SteeredVehicle;
 import com.foed.Vector2D;
 
 import flash.display.Sprite;
 import flash.display.StageAlign;
 import flash.display.StageScaleMode;
 import flash.events.Event;

 public class SeekTest extends Sprite
 {
  private var _vehicle:SteeredVehicle;
  
  public function SeekTest()
  {
   stage.align = StageAlign.TOP_LEFT;
   stage.scaleMode = StageScaleMode.NO_SCALE;
   
   _vehicle = new SteeredVehicle();
   addChild(_vehicle);
   
   addEventListener(Event.ENTER_FRAME, onEnterFrame);
  }
  
  private function onEnterFrame(event:Event):void
  {
   _vehicle.seek(new Vector2D(mouseX, mouseY));
   _vehicle.update();
  }
 }
}
这是个相当简单的例子。只是创建一个车子，放置在舞台，并且在每一帧让车子寻找鼠标并调用 update 方法。试者改变一下 maxSpeed 和 maxForce 的值，甚至可以改变其质量（mass）感受一下转向行为的变化。你也可以让它去寻找一个固定点，而非鼠标。或者玩点儿刺激的，创建另一个 Vehicle 让车子去寻找它。那么 onEnterFrame 方法可能会是这样：
    _vehicle.seek(_targetVehicle.position);
你甚至可以让一个转向机车去寻找鼠标，再让另一个转向机车去寻找第一辆。当你感觉它们都运行得不错时，我们就进入下一个行为：躲避（flee）。

Flee（躲避）行为
躲避行为与寻找行为彻底、完全、绝对的相反。事实上，它们的实现方法除了最后一行代码外全部相同，就是从 _steeringForce 中减去转向力而不是加：
public function flee(target:Vector2D):void
{
 var desiredVelocity:Vector2D = target.subtract(_position);
 desiredVelocity.normalize();
 desiredVelocity = desiredVelocity.multiply(_maxSpeed);
 var force:Vector2D = desiredVelocity.subtract(_velocity);
 _steeringForce = _steeringForce.subtract(force);
}
不需要再做任何细节的解释了，因为它和寻找行为基本相同。最后一句的意思是“Ok，我已经知道你要到达的位置了。现在掉个头往相反的方向走”。下面是一个躲避行为的简单测试（可从本书网站下载 FleeText.as）：
package
{
 import com.foed.SteeredVehicle;
 import com.foed.Vector2D;
 import com.foed.Vehicle;
 
 import flash.display.Sprite;
 import flash.display.StageAlign;
 import flash.display.StageScaleMode;
 import flash.events.Event;

 public class FleeTest extends Sprite
 {
  private var _vehicle:SteeredVehicle;
  
  public function FleeTest()
  {
   stage.align = StageAlign.TOP_LEFT;
   stage.scaleMode = StageScaleMode.NO_SCALE;
   
   _vehicle = new SteeredVehicle();
   _vehicle.position = new Vector2D(200, 200);
   _vehicle.edgeBehavior = Vehicle.BOUNCE;
   addChild(_vehicle);
   
   addEventListener(Event.ENTER_FRAME, onEnterFrame);
  }
  
  private function onEnterFrame(event:Event):void
  {
   _vehicle.flee(new Vector2D(mouseX, mouseY));
   _vehicle.update();
  }
 }
}
除了明显的调用 flee 和 seek 方法的不同之外，主要的不同是先让车子的位置略微接近舞台一点并让它在与舞台碰撞时反弹。如果你删除了那两行代码，你就知道我为什么要加了。车子把自己藏在角落以躲避鼠标，然后你可能就看不到它了。
    现在我们已经有了一对完全相反的行为了，显然下一步就要创建两个机车让它们各自拥有一种行为，然后看看它们有什么表现。下面这个例子就是要做这件事，在下载网站上的 SeekFleeTest1.as 文件：
package
{
 import com.foed.SteeredVehicle;
 import com.foed.Vector2D;
 import com.foed.Vehicle;
 
 import flash.display.Sprite;
 import flash.display.StageAlign;
 import flash.display.StageScaleMode;
 import flash.events.Event;

 public class SeekFleeTest1 extends Sprite
 {
  private var _seeker:SteeredVehicle;
  private var _fleer:SteeredVehicle;
  
  public function SeekFleeTest1()
  {
   stage.align = StageAlign.TOP_LEFT;
   stage.scaleMode = StageScaleMode.NO_SCALE;
   
   _seeker = new SteeredVehicle();
   _seeker.position = new Vector2D(200, 200);
   _seeker.edgeBehavior = Vehicle.BOUNCE;
   addChild(_seeker);
   
   _fleer = new SteeredVehicle();
   _fleer.position = new Vector2D(400, 300);
   _fleer.edgeBehavior = Vehicle.BOUNCE;
   addChild(_fleer);
   
   addEventListener(Event.ENTER_FRAME, onEnterFrame);
  }
  
  private function onEnterFrame(event:Event):void
  {
   _seeker.seek(_fleer.position);
   _fleer.flee(_seeker.position);
   _seeker.update();
   _fleer.update();
  }
 }
}
这时我们有了两辆车子：_seeker 和 _fleer。我想不必去解释 seeker 寻找 fleer，以及 fleer 躲避 seeker 了吧（试着读这句英文十遍 "The seeker seeks the fleer, and the fleer flees the seeker"！）。让它运行一会儿看看它们是怎么相互作用的。然后试着改变一些参数看看会发生什么。
    现在我们已经有不只一种行为，可以在一辆机车上应用多个行为了。接下的例子，机车 A 将寻找 B，B 要去寻找 C，而 C 再寻找 A。同时每辆机车还要躲避寻找它的机车，它们三个会彼此追逐形成一个圈。这个例子可以在 SeekFleeTest2.as 中找到，如图 2-5 所示：
package
{
 import com.foed.SteeredVehicle;
 import com.foed.Vector2D;
 import com.foed.Vehicle;
 
 import flash.display.Sprite;
 import flash.display.StageAlign;
 import flash.display.StageScaleMode;
 import flash.events.Event;

 public class SeekFleeTest2 extends Sprite
 {
  private var _vehicleA:SteeredVehicle;
  private var _vehicleB:SteeredVehicle;
  private var _vehicleC:SteeredVehicle;
  
  public function SeekFleeTest2()
  {
   stage.align = StageAlign.TOP_LEFT;
   stage.scaleMode = StageScaleMode.NO_SCALE;
   
   _vehicleA = new SteeredVehicle();
   _vehicleA.position = new Vector2D(200, 200);
   _vehicleA.edgeBehavior = Vehicle.BOUNCE;
   addChild(_vehicleA);
   
   _vehicleB = new SteeredVehicle();
   _vehicleB.position = new Vector2D(400, 200);
   _vehicleB.edgeBehavior = Vehicle.BOUNCE;
   addChild(_vehicleB);
   
   _vehicleC = new SteeredVehicle();
   _vehicleC.position = new Vector2D(300, 260);
   _vehicleC.edgeBehavior = Vehicle.BOUNCE;
   addChild(_vehicleC);
   
   addEventListener(Event.ENTER_FRAME, onEnterFrame);
  }
  
  private function onEnterFrame(event:Event):void
  {
   _vehicleA.seek(_vehicleB.position);
   _vehicleA.flee(_vehicleC.position);
   
   _vehicleB.seek(_vehicleC.position);
   _vehicleB.flee(_vehicleA.position);
   
   _vehicleC.seek(_vehicleA.position);
   _vehicleC.flee(_vehicleB.position);
   
   _vehicleA.update();
   _vehicleB.update();
   _vehicleC.update();
  }
 }
}

图 2-5  A 追逐 B，B追逐 C，C追逐 A

    同样，试着改变参数，搅乱他们，看看能创造出什么样的情形。当你准备好了，我们就进入到达行为。

Arrive（到达）行为
    达到行为在很多方面与寻找行为基本相似。实际上，它们的算法和运作方法通常是相同的。差别就是当车子到达离目标一定距离的时候就进入到达模式，此时转为一种精确模式缓动到目标点，越接近目标速度越慢。
    要看看为什么到达行为有时候非常重要，请运行一下前面的 SeekTest 类。将鼠标移动到远离车子的位置，然后让车子去“扑捉”鼠标。你将看到车子急速地经过目标；然后它好像意识到错了，调个头，又回来。这是个不确定的持续过程，因为车子总是以最快的速度向目标运动，即使只有几个像素它也会这样。

到达行为通过让车子接近目标后减速解决了这个问题：
public function arrive(target:Vector2D):void
{
 var desiredVelocity:Vector2D = target.subtract(_position);
 desiredVelocity.normalize();
 
 var dist:Number = _position.dist(target);
 if(dist > _arrivalThreshold)
 {
  desiredVelocity = desiredVelocity.multiply(_maxSpeed);
 }
 else
 {
  desiredVelocity = desiredVelocity.multiply(_maxSpeed * dist / _arrivalThreshold);
 }
 
 var force:Vector2D = desiredVelocity.subtract(_velocity);
 _steeringForce = _steeringForce.add(force);
}
前两行代码和 seek 方法一样。而期望速度和最大速度相乘之前要判断到达目标的距离。如果距离大于threshold（阈值），就还像原来那么做。在退出 if 语句后，继续执行与 seek 方法相同的程序。
    然而，如果距离小于阈值，就得做些别的事儿。我们用 _maxSpeed * dist / _arriveThreshold 代替乘 _maxSpeed。如果距离只比阈值小一点，则 dist / _arriveThreshold 会非常接近 1.0，比如 0.99。因此 desiredVelocity 会非常接近 _maxSpeed。当距离接近零时，比值会变得越来越小，从而影响期望速度 desiredVelocity 的量。因此计算出的向量也会趋近于零（假定机车只有一个行为或外力的情况下）。如图 2-6 所示。

图 2-6 如果距离在到达阈值（arrival threshold）内，则缓动到目标。否则，仅用寻找

当然，现在 SteeredVehicle 类需要新的阈值属性，所以把它加到类的顶部：
package com.foed
{
 import flash.display.Sprite;

 public class SteeredVehicle extends Vehicle
 {
  private var _maxForce:Number = 1;
  private var _steeringForce:Vector2D;
  private var _arrivalThreshold:Number = 100;
  ...
 }
}
然后我们为 arriveThreshold 添加 setter 和 getter 方法，以便能获取其值：
public function set arriveThreshold(value:Number):void
{
 _arrivalThreshold = value;
}
public function get arriveThreshold():Number
{
 return _arrivalThreshold;
}
下面的测试类中你会看到它是怎么工作的：
package
{
 import com.foed.SteeredVehicle;
 import com.foed.Vector2D;
 
 import flash.display.Sprite;
 import flash.display.StageAlign;
 import flash.display.StageScaleMode;
 import flash.events.Event;

 public class ArriveTest extends Sprite
 {
  private var _vehicle:SteeredVehicle;
  
  public function ArriveTest()
  {
   stage.align = StageAlign.TOP_LEFT;
   stage.scaleMode = StageScaleMode.NO_SCALE;
   
   _vehicle = new SteeredVehicle();
   addChild(_vehicle);
   
   addEventListener(Event.ENTER_FRAME, onEnterFrame);
  }
  
  private function onEnterFrame(event:Event):void
  {
   _vehicle.arrive(new Vector2D(mouseX, mouseY));
   _vehicle.update();
  }
 }
}
这个类与 SeekTest 的唯一不同就在 onEnterFrame 中的那一行，调用 arrive 而非 seek。移动鼠标时车子开始寻找行为，一旦鼠标不动让车子接近它，它将缓动到鼠标指针刚好的位置。再移动鼠标，车子又回到寻找模式。通过修改 arriveThreshold 的值，你能看到在多么接近目标时状态会变化。
    如果你愿意的话，可以任意加一些新车子来玩。不愿意的话呢，咱们就进入追赶行为。

    转向行为（steering behaviors）这个名词是指一系列让物体运动看似智能的算法。这些行为隶属于人工智能（artificial intelligence）和人工生命（artificial life），它们能让角色像是有自己的生命一样——可以决定自己何时、何地以及如何运动，以便可以到达目标、追逐敌人、逃离追击、躲避障碍物，以及寻路等等。

    这个名词是 Craig Reynolds 在 1999 年的游戏开发者大会上在名为“Steering Behaviors for Autonomous Characters”的论文中提出的。它描述了一系列算法用于创建一个军队系统，应用在角色游戏和模拟领域。军队通常会影响角色的运动带来角色需要和想要的东西。这其中也囊括了不同的动力的分类，如集群（flocking）行为。事实上，Reynolds 的模拟鸟群聚集的程序“boids”，已经让他广为人知了（见图 2-1）。

图 2-1  Craig Reynolds 的 “boids”

    现在，你可以在http://www.red3d.com/cwr/steer/ 中找到 Reynolds 的网站，快速的搜索一下这个标题，你会找到很多下载地址。这个网站虽然提到了一个开源的 C++ 版本的行为控制框架：OpenSteer (http://opensteer.sourceforge.net/) 但是 Reynolds 并没有非常深入地实现这套算法。不过，他在网页中描述的这个系统已经做了很多的基础工作，这也是人工智能运动引擎建立的基石。本章将跟随这些脚步，创建一个基于 ActionScript 3.0 版本的引擎包括网站中描述最多的行为。
    在本章开始之前，要了解本章的目标是介绍行为，了解行为，并展示一个实现每种行为的框架。一些更为复杂的行为可以有许多不同的解决方法，伴随大量不同级别的复杂度。这里并不需要一个“标准”或“正确” 方法处理所有这些行为，并且我给的实现方法都是尽量简单的。换句话讲，考虑到这是一个引导和起点。对于产品级的应用来说，目前这些代码还需要大量改进，就像为你的应用量身定做。

行为
    首先，让我们看看基本的行为有哪些——每一个是做什么的以及用于什么地方：
■ 寻找（seek)：角色试图移动到某个指定点。该点可以是一个固定点或是移动目标，例如另一个角色。
■ 躲避（flee）：和寻找行为完全相反。角色尽可能向避开指定点的方向移动。同样，这个点即可是固定的也可是运动的。
■ 到达（arrive）: 和寻找行为相同，只是角色足够接近目标点时速度会降下来，就像缓动运动最终停在目标点一样。
■ 追赶（pursue）：寻找行为的改进版，加入了对目标的速度的计算。不只寻找目标当前所在的点，而要预先判断目标要去哪里并向此点移动。显然，这个行为只应用在移动目标，因为固定点是没有速度的。
■ 逃离（evade）：与追赶完全相反。角色预先根据对方的速度判断到达的点，然后尽可能地远离该点。
■ 漫游（wander）：随机但又平滑真实的移动。
■ 物体躲避（object avoidance）：角色可以察觉在其运动路径上的物体并转向躲避它们。
■ 路径跟随（path following）：角色尽量保持在指定路径上，但这是在持续的物理和其它行为干扰下实现的。
除了这些行为以外，还有复杂的复合行为，如我们熟知的集群（flocking）模拟相似角色的群组行为，基本上是应用其它三种简单行为创造出来的：
■ 分离（separation）：集群中的每个角色试图与他的邻居保持一定距离。
■ 凝聚（cohesion）：每个角色试图不要离他的邻居太远。
■ 队列（alignment）：每个角色试图与他的邻居保持相同的转向。
    虽然这三个行为都相当简单，但是当把它们加以组合，则会产生一些惊人的动态效果，真正让你感觉看到的是一群鸟或者其它一群生物。调整三个子行为参数可以改变群组的性质，导致某些群落经常脱离队伍，或是紧密交织的一个群落，或是一列群体追随一个头领，或是其他的变化。
    在让物体以行为方式运动之前，我们先要找出一个让它们运动的方法。

Vector2D 类
    转向行为被多种不同的编程语言实现过（ActionScript 大概也有一两次）。最初是用向量（在绝大多数实现中你将发现）进行描述的。（如果你想学习更多有关向量的知识，可以参考 Foundation ActionScript 3.0 Animation: Making Things Move!，在这里有更多细节。）
    简而言之，向量（vector）描述了一个有方向和量的东西。例如，一个运动物体的向量包括运动的路径（方向）以及它的速度（量）。因此速度向量（velocity）是最适合表示这种向量的了。加速度（Acceleration）——如何改变物体速度向量的力——也包括外力的量和方向（另一种向量）。向量也能很好表达两个物体的相对位置，量就是它们间的距离而方向则是它们间的角度。
    此外，你可以使用向量来描述角色的朝向。这个例子，没有任何量，只有方向，所以你可以设置量为 1.0。这种向量称作单位向量（unit vector），实际上它只有一个单位长度，这样让它的数学运算表现更好。
    向量的所有这些特性都对转向行为非常有用，因为会被大量用于速度向量，军团方向，物体间距离以及物体朝向中。所以创建一个 ActionScript 3.0 的向量类对转向行为系统将是非常有用。我作为一个好人，我要为你们创建它。当然，我后来发现 Flash CS4 自身已经有了 Vector3D 类，因此你最终可能要超越它。但是我发现额外的这个维度让计算变得有些复杂，所以我决定在本章还是用我自己轻量级的 Vector2D 类。我不会太过深入地解释它，它包含了最为有用的方法，你可以在其它语言相似的类中找到这些方法，尤其是那些用于转向行为的方法。我将在这里把它全部呈现出来，让大家更好参考。当我们使用这个类中的方法时，我会解释一些细节。大家可以在本书的下载页面 www.friendsofed.com 中找到 Vector2D.as 文件。
package com.foed
{
 import flash.display.Graphics;
 
 
 public class Vector2D
 {
  private var _x:Number;
  private var _y:Number;
  
  
  public function Vector2D(x:Number = 0, y:Number = 0)
  {
   _x = x;
   _y = y;
  }
  
  
  public function draw(graphics:Graphics, color:uint = 0):void
  {
   graphics.lineStyle(0, color);
   graphics.moveTo(0, 0);
   graphics.lineTo(_x, _y);
  }
  
  
  public function clone():Vector2D
  {
   return new Vector2D(x, y);
  }
  
  
  public function zero():Vector2D
  {
   _x = 0;
   _y = 0;
   return this;
  }
  
  
  public function isZero():Boolean
  {
   return _x == 0 && _y == 0;
  }
  
  
  public function set length(value:Number):void
  {
   var a:Number = angle;
   _x = Math.cos(a) * value;
   _y = Math.sin(a) * value;
  }
  public function get length():Number
  {
   return Math.sqrt(lengthSQ);
  }
  
  
  public function get lengthSQ():Number
  {
   return _x * _x + _y * _y;
  }
  
  
  public function set angle(value:Number):void
  {
   var len:Number = length;
   _x = Math.cos(value) * len;
   _y = Math.sin(value) * len;
  }
  public function get angle():Number
  {
   return Math.atan2(_y, _x);
  }
  
  
  public function normalize():Vector2D
  {
   if(length == 0)
   {
    _x = 1;
    return this;
   }
   var len:Number = length;
   _x /= len;
   _y /= len;
   return this;
  }
  
  
  public function truncate(max:Number):Vector2D
  {
   length = Math.min(max, length);
   return this;
  }
  
  
  public function reverse():Vector2D
  {
   _x = -_x;
   _y = -_y;
   return this;
  }
  
  
  public function isNormalized():Boolean
  {
   return length == 1.0;
  }
  
  
  public function dotProd(v2:Vector2D):Number
  {
   return _x * v2.x + _y * v2.y;
  }
  
  
  public function crossProd(v2:Vector2D):Number
  {
   return _x * v2.y - _y * v2.x;
  }
  
  
  public static function angleBetween(v1:Vector2D, v2:Vector2D):Number
  {
   if(!v1.isNormalized()) v1 = v1.clone().normalize();
   if(!v2.isNormalized()) v2 = v2.clone().normalize();
   return Math.acos(v1.dotProd(v2));
  }
  
  
  public function sign(v2:Vector2D):int
  {
   return perp.dotProd(v2) < 0 ? -1 : 1;
  }
  
  
  public function get perp():Vector2D
  {
   return new Vector2D(-y, x);
  }
  
  
  public function dist(v2:Vector2D):Number
  {
   return Math.sqrt(distSQ(v2));
  }
  
  
  public function distSQ(v2:Vector2D):Number
  {
   var dx:Number = v2.x - x;
   var dy:Number = v2.y - y;
   return dx * dx + dy * dy;
  }
  
  
  public function add(v2:Vector2D):Vector2D
  {
   return new Vector2D(_x + v2.x, _y + v2.y);
  }
  
  
  public function subtract(v2:Vector2D):Vector2D
  {
   return new Vector2D(_x - v2.x, _y - v2.y);
  }
  
  
  public function multiply(value:Number):Vector2D
  {
   return new Vector2D(_x * value, _y * value);
  }
  
  
  public function divide(value:Number):Vector2D
  {
   return new Vector2D(_x / value, _y / value);
  }
  
  
  public function equals(v2:Vector2D):Boolean
  {
   return _x == v2.x && _y == v2.y;
  }
  
  
  public function set x(value:Number):void
  {
   _x = value;
  }
  public function get x():Number
  {
   return _x;
  }
  
  
  public function set y(value:Number):void
  {
   _y = value;
  }
  public function get y():Number
  {
   return _y;
  }
  
  
  public function toString():String
  {
   return "[Vector2D (x:" + _x + ", y:" + _y + ")]";
  }
 }
}
C 和 C++ 语言都有非常优雅的特性叫做操作符重载（operator overloading）允许你映射一个系统内置的操作符，如 + 或 -，做为类的方法。这样的话，我们可以用 vectorC = vectorA + vectorB，代替 vectorC = vectorA.add(vectorB)。
    虽然操作符重载让类更接近本地语言并且变得更容易理解，但是 ActionScript 目前还不支持这样做，所以我们只能用单词方法来实现。
    设计这样一个类的最大挑战是决定某些方法应该如何工作——在本例中，比如 truncate（截断）、normalize（规范化）、reverse（倒置）、add（加法）、subtract（减法）、multiply（乘法）以及 divide（除法）方法。我们有两种可能的实现方式：一种方式如相加（add）可以直接改变被调对象本身的状态，也可以返回一个相加（add）结果的新对象。
    例如，我们有一个 vectorA 等于 (3, 2) 表示它 x 值为 3，y 为 2，以及一个 vectorB 等于 (4, 5)。然后运行如下代码：
    vectorA.add(vectorB);
根据上学时的思维，vectorB 不会发生变化，但是 vectorA 应该变为 (7, 7)。
另一种可能是这样的：
    vectorC = vectorA.add(vectorB);
这里 vectorA 和 vectorB 的值都保持不变 (3, 2) 和 (4, 5)，而新创建的 vectorC 应该等于 (7, 7)。
那么这两种加法哪个是正确的呢？在创建这个类的时候我犹豫许久，最终我意识到很多情况下比如用对象自身位置或速度做数学运算时不需要改变对象自身的值。因此在做 add、subtract 和 divide 操作时保持对象自身属性不变。
    然而，做 truncate、reverse 和 normalize 运算时通常意味着直接对对象做操作。所以直接改变对象的属性值比返回一个新的实例更为有用。
    互换实现方法并不难。例如，让 vectorB 和vectorA 相加，再让 vectorA 获得相加结果，可以这样做：
    vectorA = vectorA.add(vectorB);
如果你想要做 truncate、reverse 和 normalize 运算而不改变原有的值，可以使用 clone 方法如：
    normalizedA = vectorA.clone().normalize();
这个方法创建一个 vectorA 的拷贝并对其做规范化，保持原始的 vectorA 不变。
    在 Seb Lee-Delisle 做本书的技术评审时指出像这样创建对象的拷贝会导致大量临时对象被创建，然后销毁。这就需要 Flash Player 的垃圾回收机跟踪所有这些无效对象并移除它们，会引起效率问题。我之所以选择这样是为了代码清晰，但我也知道这是个可以优化的地方。
    现在我们已经有了表示角色位置、速度以及外力的向量类，接下来需要一个简单的类表示角色。

Zynga is the #1 social gaming company in the world, and one of the fastest growing Internet companies in history.  At Zynga, our mission is to connect people through our games.  At Zynga, you will find smart, creative people who are passionate about taking on new challenges. Whether you are a developer, designer, or a customer service manager, there’s an opportunity here for you to level up and be your own CEO.

These positions are for our office in Beijing, we are looking for the best and brightest candidates to help up build a stellar team!

For more information, please visit our website: http://www.zynga.com.

We have the following HR positions open

• Technical Recruiter
• HR Manager

Technical Recruiter 
 
Zynga is looking for a Technical Recruiter to help us grow our China office!   The ideal candidate has strong research skills and ability to attract passive talent.   Dealing with some of the largest applications in the world, we both demand and are privileged to hold a high technical bar.  We are growing quickly, and require demonstrated experience working on a fast paced technical recruiting team. 
  
We are committed to developing high quality casual and multi player games!  Come join us ... we're having a ball!  
  
Responsibilities:

• Identify, attract, and screen candidates for engineering and product teams
• Finding creative and effective resources to source viable candidates (blogs, user-groups and beyond)
• Schedule  phone screens and on site interviews with the leadership team
• Negotiate salaries and create offer proposals

• 4 years of technical sourcing and candidate development
• Strong research skills
• Solid understanding of consumer web and gaming industry
• Proven track-record of attracting top engineering talent
• Fluent in Boolean logic search techniques and other passive candidate techniques
• Self directed
• Ability to prioritize
• Broad knowledge of programming languages, web technologies, software development process and emerging technologies
• Ability to maintain strong relationships with recruiters and candidates
• Fluent in spoken and written English

Human Resource Manager

Do you have a passion for building great Human Resources programs in an organization? If you have had a strong record of success in Human Resources we would love to talk to you! We are looking for a seasoned Human Resources Manager to join our international team. This individual will report to our Chief People Officer, and work out of our Beijing office. 
  
Responsibilities:

• Actively provide human resources expertise in employee relations, coaching/development, compensation, conflict management, organizational development and training throughout Europe
• Manage Zynga’s performance review program
• Engage and influence senior management to support and implement HR initiatives across the organization
• Research and assist on learning & development and training opportunities for Zynga
• Lead the development and implementation of systems and processes to drive continuous learning and knowledge sharing across the organization in support of the business strategies
• Work with customer groups to update and apply policies and procedures consistently across the business
• Actively participate in the administration of benefits and compensation programs  

Required Skills:

• BA/BS Minimum (Business or HR degree preferred)
• 3-5 years or more of applicable experience
• Strong communication skills
• Experience in the administration of benefits and compensation programs and other Human Resources programs within an international setting
• Ability to work with minimal supervision
• Excellent problem solving skills
• Experience with exceptionally fast paced environments
• Ability to handle a large amount of ambiguity
• Demonstrated ability to manage projects from end to end
• Fluent in spoken and written English

Nice To Have:

• 8 - 10 years progressive experience
• Masters degree
• Strong partnership and generalist experience
• Software company experience as a HR business partner
• Organizational development and management coaching experience

    现在试着增加格子的大小，比如 100。你会注意到碰撞检测的次数明显变多，因为每个方格中的小球更多了。听起来不好，但却会减少方格和数组循环的次数，一会儿我们会看到它的好处。

    现在减少网格数量到 40 或 30。碰撞检测的次数减少了，看起来更符合要求。大家可能会偶尔看到丢失碰撞的情况 —— 两个物体在碰撞后没有变化（仍是白色）。这可不好，但它却提醒我们网格大小要能容纳最大的物体。由此进一步，根据最大的物体动态设置网格大小。

将网格大小设为 50 并修改 makeBalls 创建小球的一句：
    var ball:Ball = new Ball(Math.random() * RADIUS);
这个改变不会影响判断次数；执行效果很好。它只是告诉我们即使物体大小不同，程序仍可正确运行——当然要切记网格大小的规则。

    现在做一些小小的调整，看看会有什么不同，尤其是“当前格子中物体间的比较”方法。

    我们需要创建一个新的方法来完成此任务，叫它 basicCheck() 方法，内容如下：
private function basicCheck():void {
 for(var i:int = 0; i < _balls.length - 1; i++) {
  var ballA:Ball = _balls[i] as Ball;
  for(var j:int = i + 1; j < _balls.length; j++) {
   var ballB:Ball = _balls[j] as Ball;
   checkCollision(ballA, ballB);
  }
 }
}
这是 100 个物体产生 4950 次碰撞检测的代码。我们已经用更少的判断次数战胜了这种方法，但是它没有大量网格计算的开销。那么这两种方式如何比较呢？我们真能从中受益吗？

    显然必须看到一些优点，否则这一章也就不存在了，要让大家耳闻不如一见。我们要做的是让基于网格判断的代码执行十次，同时执行这个方法十次，看看哪种用时最少。我会将代码写在构造函数中，变化如下：
public function GridCollision() {
 stage.align = StageAlign.TOP_LEFT;
 stage.scaleMode = StageScaleMode.NO_SCALE;
 
 makeBalls();
 drawGrid();
 
 var startTime:int;
 var elapsed:int;
 var i:int;
 
 // 获得初始化时间
 startTime = getTimer();
 // 做 10 次循环
 for(i = 0; i < 10; i++) {
  makeGrid();
  assignBallsToGrid();
  checkGrid();
 }
 // 用当前时间减去开始时间
 elapsed = getTimer() - startTime;
 trace("Grid-based:", elapsed);
 // 再做十次基本判断
 startTime = getTimer();
 for(i = 0; i < 10; i++) {
  basicCheck();
 }
 elapsed = getTimer() - startTime;
 trace("Basic check", elapsed);
}
创建开始时间的变量，然后计算消耗的时间。将开始时间设置为 getTimer() 并执行十次下面这三行代码：
 makeGrid();
 assignBallsToGrid();
 checkGrid();
用当前时间减去开始时间，看看用时多久。再把 basicCheck() 执行十次。

    结果如何呢？在我这儿，基于网格的方法执行速度比基本的方法快了 2.5 倍。没有我之前期望得那么厉害，可是我们明明已经节省了 4800 次碰撞检测啊。这说明网格方法还有很大的系统开销。但是，2.5 倍的速度提升也不赖啊，不是么？

    此外，物体越多节省的开销也就也多。如果我增加 _numBalls 到 1000，那么基于网格的方法处理速度不到 1 秒，反之基本判断方法需要多达 13 秒。（当然，一秒钟一帧是不可接受的帧率，但是也比每帧 13 秒强得多吧！）另外，如果将小球的数量减少到 50 个，基本的判断确实很快。因此在系统开销超过碰撞检测节省部分的分水岭时，最好改用简单的方法。这个分水岭到底在哪，那要按你的应用中需要检测的物体而定。

    将 _numBalls 设置回 100 再运行几次，你就会知道网格方法需要多长时间。在我的机器上，10 次的平均值为 55 毫秒。现在将网格大小从 50 改为 75。我们平均值从降到了 37 毫秒。我发现网格大小在 85 到 100 之间平均用时为 32 毫秒，是基本检测方法的四倍！注意，所有这些数字都只是作为指导性的例子。你可能会得到非常不同的结果。节省开销的重要方法是调整网格大小，要找到适合你应用程序的最佳值。这里有很多变量：舞台大小，物体数量，物体大小，网格大小以及碰撞检测的算法（不以某台电脑的表现为标准）。我还没有想出一个能够得到最佳参数的神奇公式。

将它改为可重用的类
通过 GridCollision 类希望大家能从网格级碰撞检测中领悟到其背后的思想，证明它存在的价值。但它确实还有不少问题。首先，它在主文档类中，因此需要拷贝粘贴到另一个应用中。因此它与 Ball 类耦合度很高。如果想在其它类中作为对象使用它，你就要改变这个类的所有引用。而且，碰撞检测的算法是基于距离的。你可能要用简单的 hitTestObject 或是位图级的碰撞检测。所以我们要创建一个新的类来应对这些问题，我会尽可能地做到最优化。这个类就叫它 CollisionGrid，可从 www.friendsofed.com 下载：
package {
 import flash.display.DisplayObject;
 import flash.display.Graphics;
 import flash.events.EventDispatcher;
 
 public class CollisionGrid extends EventDispatcher {
  private var _checks:Vector.<DisplayObject>;
  private var _grid:Vector.<Vector.<DisplayObject>>;
  private var _gridSize:Number;
  private var _height:Number;
  private var _numCells:int;
  private var _numCols:int;
  private var _numRows:int;
  private var _width:Number;
  
  public function CollisionGrid(width:Number, height:Number, gridSize:Number) {
   _width = width;
   _height = height;
   _gridSize = gridSize;
   _numCols = Math.ceil(_width / _gridSize);
   _numRows = Math.ceil(_height / _gridSize);
   _numCells = _numCols * _numRows;
  }
  
  public function drawGrid(graphics:Graphics):void {
   // 绘制线条表示网格
   graphics.lineStyle(0, .5);
   for(var i:int = 0; i <= _width; i += _gridSize) {
    graphics.moveTo(i, 0);
    graphics.lineTo(i, _height);
   }
   for(i = 0; i <= _height; i += _gridSize) {
    graphics.moveTo(0, i);
    graphics.lineTo(_width, i);
   }   
  }
  
  public function check(objects:Vector.<DisplayObject>):void {
   var numObjects:int = objects.length;
   _grid = new Vector.<Vector.<DisplayObject>>(_numCells);
   _checks = new Vector.<DisplayObject>();
   // 遍历所有对象
   for(var i:int = 0; i < numObjects; i++) {
    var obj:DisplayObject = objects[i];
    // 用一个小标表示在一维网格中的位置
    var index:int = Math.floor(obj.y / _gridSize) * _numCols + Math.floor(obj.x / _gridSize);
    if(_grid[index] == null) _grid[index] = new Vector.<DisplayObject>;
    // 将对象放入格子中
    _grid[index].push(obj);
   }
   
   checkGrid();
  }
  
  private function checkGrid():void {
   // 循环遍历每个格子
   for(var i:int = 0; i < _numCols; i++) {
    for(var j:int = 0; j < _numRows; j++) {
     // 第一个格子中所有的对象间的碰撞检测
     checkOneCell(i, j);
     checkTwoCells(i, j, i + 1, j);
     checkTwoCells(i, j, i - 1, j + 1);
     checkTwoCells(i, j, i,     j + 1);
     checkTwoCells(i, j, i + 1, j + 1);
    }
   }
  }
  
  private function checkOneCell(x:int, y:int):void {
   // 根据 x, y 获得格子
   var cell:Vector.<DisplayObject> = _grid[y * _numCols + x];
   if(cell == null) return;
   
   // 格子中对象的数量
   var cellLength:int = cell.length;
   
   // 所有对象间相互比较
   for(var i:int = 0; i < cellLength - 1; i++) {
    var objA:DisplayObject = cell[i];
    for(var j:int = i + 1; j < cellLength; j++) {
     var objB:DisplayObject = cell[j];
     _checks.push(objA, objB);
    }
   }
  }
  
  private function checkTwoCells(x1:int, y1:int, x2:int, y2:int):void {
   // 确保格子的存在
   if(x2 >= _numCols || x2 < 0 || y2 >= _numRows) return;
   var cellA:Vector.<DisplayObject> = _grid[y1 * _numCols + x1];
   var cellB:Vector.<DisplayObject> = _grid[y2 * _numCols + x2];
   if(cellA == null || cellB == null) return;
   
   var cellALength:int = cellA.length;
   var cellBLength:int = cellB.length;
   
   // 网格中所有对象间的比较
   for(var i:int = 0; i < cellALength; i++) {
    var objA:DisplayObject = cellA[i];
    for(var j:int = 0; j < cellBLength; j++) {
     var objB:DisplayObject = cellB[j];
     _checks.push(objA, objB);
    }
   }
  }
  
  public function get checks():Vector.<DisplayObject> {
   return _checks;
  }
 }
}
大多数代码与前面的例子相同。有一些已经被优化过了，特别是使用了 Vector （向量）。Vector 是 Flash 10 的新特性，本质上是数组类型。因为编译器知道向量中的元素是同一类型，它可以在运行时创建出更高效的字节编码。用 Vector 替换数组能让我们的程序效率提高近两倍！

    drawGrid() 方法与前面的没有差别，用来绘制网格！

    check() 方法是与这个类交互的公共方法，需要传一个显示对象的向量给它。我选择 DisplayObject 是因为用于碰撞检测的对象通常是 Sprite、MovieClip、Shape 或 Bitmap，它们都是从 DisplayObject 继承过来的。DisplayObject 都有 x 和 y 属性，用来获取坐标从而判断它们在网格中的位置。如果你使用没有从 DisplayObject 继承来的自定义类，那么请更改此类型。

    check() 方法创建一个 _grid 和一个 _checks 向量。大家对 _grid 很熟悉，但是这里它的实现方法有些不同——一维向量可以用巧妙运用下标代替二维数组。这样做的原因是效率更高并且遍历一维数组占用的资源要比二维数组少。简单的过一下，_checks 向量用于保存碰撞检测对象列表。注意 CollisionGrid 类本身不做碰撞检测。它创建一个网格，分配对象，生成一个碰撞对象列表。是否要遍历这个数组进行碰撞检测取决于你。

    接下来，遍历传入的 DisplayObject 向量，并将每个对象分配到网格中，这小段代码可能需要解释一下：
 for(var i:int = 0; i < numObjects; i++) {
  var obj:DisplayObject = objects[i];
  // 用下标表示在一维网格中的位置
  var index:int = Math.floor(obj.y / _gridSize) * _numCols + Math.floor(obj.x / _gridSize);
  if(_grid[index] == null) _grid[index] = new Vector.<DisplayObject>;
  // 将对象放入格子中
  _grid[index].push(obj);
 }
重申一遍，我们使用的是一维向量代替二维数组。通过 index 变量找出向量中相对应的行和列。基本公式如下，x 和 y 是行和列的下标：
    index = y * numColumns + x
图 1-21 应该能够解释。

图 1-21 使用一个平坦化数组作网格

这个网格有五行五列。物体在二行三列的位置上，因此 x = 3 并且 y = 2。因此下标为 2 * 5 + 3 = 13，这就是我们在网格中看到的。

代码中，还像之前那样获得行和列下标：
    Math.floor(obj.x / _gridSize)
    Math.floor(obj.y / _gridSize)
唯一不同的是，我们将所有事情都写在一行代码中：
    index:int = Math.floor(obj.y / _gridSize) * _numCols +
    Math.floor(obj.x / _gridSize);
下面一行代码又是一个优化技巧。为每个格子创建一个向量而不是循环创建，有些格子可能永远不会用到。我们只判断是否存在一个向量，如果不存在，则创建。这是一个懒汉式的例子。在这里“懒汉”并不是一个贬义词。

它是指如果你不需要某些对象就先不去创建它们。有些情况下这种方式有意义而有些情况没有意义。在这里使用它是个好点子：
    if(_grid[index] == null) _grid[index] = new Vector.<DisplayObject>;
下面是循环的最后一行代码，向量已存在并将对象 push 进去：
    _grid[index].push(obj);
check() 的最后一行调用 checkGrid()，在这里复述一遍：
 private function checkGrid():void {
  // 循环遍历每个格子
  for(var i:int = 0; i < _numCols; i++) {
   for(var j:int = 0; j < _numRows; j++) {
    // 第一个格子中所有的对象间的碰撞检测
    checkOneCell(i, j);
    checkTwoCells(i, j, i + 1, j);
    checkTwoCells(i, j, i - 1, j + 1);
    checkTwoCells(i, j, i,     j + 1);
    checkTwoCells(i, j, i + 1, j + 1);
   }
  }
 }
这里和前面的例子没有任何不同。

    checkOneCell() 和 checkTwoCells() 方法本质是相同的。它们都用一维向量代替二维数组，首先判断格子是否为空，只有在真正需要格子的时候才会创建向量。我们只把要做碰撞检测的两个对象放在 _checks 向量中，而不是直接进行碰撞检测。

    全部结束后，_check 中保存了要相互碰撞检测的对象列表。这是个简单的列表，其中每两个元素之间都需要做碰撞检测（也就是，元素 0 和 1进行判断，2和3，4和5等等）。最终，我们提供一个名为 checks 的 public getter 方法来访问该列表。

使用这个类
    好的，我们已经有了这个可爱的类，下面看看它是如何运行的。这里我已经修改了 main 类，命名为 GridCollision2。和其它类一样，可以在 www.friendsofed.com 下载。
package {
 import flash.display.Sprite;
 import flash.display.StageAlign;
 import flash.display.StageScaleMode;
 import flash.utils.getTimer;
 import flash.display.DisplayObject;

 public class GridCollision2 extends Sprite {
  private const GRID_SIZE:Number = 80;
  private const RADIUS:Number = 25;
  
  private var _balls:Vector.<DisplayObject>;
  private var _grid:CollisionGrid;
  private var _numBalls:int = 100;
  
  public function GridCollision2() {
   stage.align = StageAlign.TOP_LEFT;
   stage.scaleMode = StageScaleMode.NO_SCALE;
   
   _grid = new CollisionGrid(stage.stageWidth, stage.stageHeight, GRID_SIZE);
   _grid.drawGrid(graphics);
   
   makeBalls();

   var startTime:int;
   var elapsed:int;
   
   // 循环十次并计算耗时
   startTime = getTimer();
   for(var i:int = 0; i < 10; i++) {
    _grid.check(_balls);
    var numChecks:int = _grid.checks.length;
    for(var j:int = 0; j < numChecks; j += 2) {
     checkCollision(_grid.checks[j] as Ball, _grid.checks[j + 1] as Ball);
    }
   }
   elapsed = getTimer() - startTime;
   trace("Elapsed:", elapsed);
  }
  
  private function makeBalls():void {
   // 创建小球，加入显示列表和 _balls 列表
   _balls = new Vector.<DisplayObject>(_numBalls);
   for(var i:int = 0; i < _numBalls; i++) {
    var ball:Ball = new Ball(RADIUS);
    ball.x = Math.random() * stage.stageWidth;
    ball.y = Math.random() * stage.stageHeight;
    ball.vx = Math.random() * 4 - 2;
    ball.vy = Math.random() * 4 - 2;
    addChild(ball);
    _balls[i] = ball;
   }
  }
  
  private function checkCollision(ballA:Ball, ballB:Ball):void {
   // 两个小球间的碰撞检测
   var dx:Number = ballB.x - ballA.x;
   var dy:Number = ballB.y - ballA.y;
   var dist:Number = Math.sqrt(dx * dx + dy * dy);
   if(dist < ballA.radius + ballB.radius) {
    ballA.color = 0xff0000;
    ballB.color = 0xff0000;
   }
  }
 }
}
主要的变化在构造函数中。因为创建和绘制网格的工作都封装在 CollisionGrid 类中，因此这里只用一行代码就搞定了，我把原有的 makeGrid() 和 drawGrid() 方法移除，直在构造函数中完成这些工作。

    接下来调用 makeBalls() 方法。除了使用向量代替数组以后，其它都和前面的例子完全相同。

    这里只有一个计时器，因为只对这个新的类的测试感兴趣。你完全可以再为基本的检测方法创建另一个计时器加以对比，不过你应该已经知道它需要多少时间了。这个循环中，调用 _grid.check(_balls) 方法前面已经深入地讲解过了。当这个方法完成以后，在 _grid.checks 中就有了一个可比较对象的向量。下面这个循环告诉我们如何使用它：
 for(var j:int = 0; j < numChecks; j += 2) {
  checkCollision(_grid.checks[j] as Ball, _grid.checks[j + 1] as Ball);
 }
这里循环遍历这个向量，每次递增 2；然后获取后两个元素，下标为 j 和 j + 1。将它们转型为 Ball 并传给 checkCollision() 方法。

    在我的测试中，这个程序比之前的例子快了近一倍，主要因为使用了向量以及在用到格子的时候才创建向量（懒实例化）有关。重头戏要开始了，可以开始编动画了。

    动画与单独碰撞没有太大的区别；恰恰是我们最常做的。由于我们已经提前调整了引擎为舞台大小、对象数量并且计算出需要处理的网格数量，因此可以删除计时循环。但是别忘了，在新项目中使用基于网格的碰撞检测时，需要根据应用改变其参数，并对新的变化做一些计时测试。

    我们的 main 类将变成这样：
package {
 import flash.display.Sprite;
 import flash.display.StageAlign;
 import flash.display.StageScaleMode;
 import flash.display.DisplayObject;
 import flash.events.Event;

 public class GridCollision3 extends Sprite {
  private const GRID_SIZE:Number = 80;
  private const RADIUS:Number = 25;
  
  private var _balls:Vector.<DisplayObject>;
  private var _grid:CollisionGrid;
  private var _numBalls:int = 100;
  
  public function GridCollision3() {
   stage.align = StageAlign.TOP_LEFT;
   stage.scaleMode = StageScaleMode.NO_SCALE;
   
   _grid = new CollisionGrid(stage.stageWidth, stage.stageHeight, GRID_SIZE);
   _grid.drawGrid(graphics);
   
   makeBalls();
   addEventListener(Event.ENTER_FRAME, onEnterFrame);
  }
  
  function onEnterFrame(event:Event):void {
   // 每个小球的速度向量增加
   updateBalls();
   // 确认哪些小球需要判断
   _grid.check(_balls);
   var numChecks:int = _grid.checks.length;
   for(var j:int = 0; j < numChecks; j += 2) {
    checkCollision(_grid.checks[j] as Ball, _grid.checks[j + 1] as Ball);
   }
  }
  
  private function makeBalls():void {
   _balls = new Vector.<DisplayObject>(_numBalls);
   for(var i:int = 0; i < _numBalls; i++) {
    var ball:Ball = new Ball(RADIUS);
    ball.x = Math.random() * stage.stageWidth;
    ball.y = Math.random() * stage.stageHeight;
    ball.vx = Math.random() * 4 - 2;
    ball.vy = Math.random() * 4 - 2;
    addChild(ball);
    _balls[i] = ball;
   }
  }
  
  private function updateBalls():void {
   for(var i:int = 0; i < _numBalls; i++) {
    // 移动每个小球，遇到墙时反弹
    var ball:Ball = _balls[i] as Ball;
    ball.update();
    if(ball.x < RADIUS) {
     ball.x = RADIUS;
     ball.vx *= -1;
    } else if(ball.x > stage.stageWidth - RADIUS) {
     ball.x = stage.stageWidth - RADIUS;
     ball.vx *= -1;
    }
    if(ball.y < RADIUS) {
     ball.y = RADIUS;
     ball.vy *= -1;
    } else if(ball.y > stage.stageHeight - RADIUS) {
     ball.y = stage.stageHeight - RADIUS;
     ball.vy *= -1;
    }
    ball.color = 0xffffff;
   }
  }
  
  private function checkCollision(ballA:Ball, ballB:Ball):void {
   // 两个小球间进行比较
   var dx:Number = ballB.x - ballA.x;
   var dy:Number = ballB.y - ballA.y;
   var dist:Number = Math.sqrt(dx * dx + dy * dy);
   if(dist < ballA.radius + ballB.radius) {
    ballA.color = 0xff0000;
    ballB.color = 0xff0000;
   }
  }
 }
}
主要的变化在新添加的 onEnterFrame() 和 updateBalls() 方法。构造函数只是创建网格和小球并开启 ENTER_FRAME 侦听。onEnterFrame() 方法通过 updateBalls() 方法更新每个小球的位置并做碰撞检测。updateBalls() 方法负责移动物体并将小球控制在屏幕范围内，以及在每帧开始的时候将小球颜色设置回白色。只有在 checkCollision() 方法产生碰撞时才将它们设置为红色。

    当然，你现在可以使用不同的碰撞作用力让小球有真正碰撞后的反弹效果。这些内容在 Making Things Move 中的“动量守恒”中有具体的介绍。

    这种碰撞检测的方法通过几次反作用力会增加物体在屏幕上移动的次数。要记住调优的秘诀就是测试，测试，测试到最佳状态并且保证碰撞检测的精确性。

碰撞检测：不只用于碰撞
    当你看到碰撞检测这个词，自然会想到两个物体相互碰撞。特别在使用基于距离的检测时，我们更容易想成两个物体的空间关系。你也许不只对碰撞感兴趣，更对两个物体是否在某个范围感兴趣。比如在游戏中，为了能看到敌人，那么它必须有许多像素是“好人”。

    我们仍然可以使用基于网格的碰撞检测，但是不再由物体的大小决定网格的大小，最重要的替换是两物体间的距离。在 Making Things Move 中有一个粒子引力的示例，是从 Jared Tarbell 的 Node Garden （www.levitated.net）中获得的灵感。我发现这是一个转换网格完美的例子，于是就把它写了出来。首先来看一下原始的代码：
package {
 import flash.display.Sprite;
 import flash.display.StageScaleMode;
 import flash.display.StageAlign;
 import flash.events.Event;
 import flash.geom.Point;

 [SWF(backgroundColor=0x000000)]
 public class NodeGardenLines extends Sprite {
  private var particles:Array;
  private var numParticles:uint = 30;
  private var minDist:Number = 100;
  private var springAmount:Number = .001;
  
  public function NodeGardenLines() {
   init();
  }
  
  private function init():void {
   stage.scaleMode = StageScaleMode.NO_SCALE;
   stage.align = StageAlign.TOP_LEFT;
   particles = new Array();
   for(var i:uint = 0; i < numParticles; i++) {
    // 创建所有粒子
    var particle:Ball = new Ball(3, 0xffffff);
    particle.x = Math.random() * stage.stageWidth;
    particle.y = Math.random() * stage.stageHeight;
    particle.vx = Math.random() * 6 - 3;
    particle.vy = Math.random() * 6 - 3;
    addChild(particle);
    particles.push(particle);
   }
   
   addEventListener(Event.ENTER_FRAME, onEnterFrame);
  }

  private function onEnterFrame(event:Event):void {
   graphics.clear();
   for(var i:uint = 0; i < numParticles; i++) {
    // 更新所有的粒子，并控制在屏幕内
    var particle:Ball = particles[i];
    particle.x += particle.vx;
    particle.y += particle.vy;
    if(particle.x > stage.stageWidth) {
     particle.x = 0;
    } else if(particle.x < 0) {
     particle.x = stage.stageWidth;
    }
    if(particle.y > stage.stageHeight) {
     particle.y = 0;
    } else if(particle.y < 0) {
     particle.y = stage.stageHeight;
    }
   }
    
   for(i=0; i < numParticles - 1; i++) {
    var partA:Ball = particles[i];
    for(var j:uint = i + 1; j < numParticles; j++) {
     // 粒子间的弹性运动
     var partB:Ball = particles[j];
     spring(partA, partB);
    }
   }
  }
  
  private function spring(partA:Ball, partB:Ball):void {
   var dx:Number = partB.x - partA.x;
   var dy:Number = partB.y - partA.y;
   var dist:Number = Math.sqrt(dx * dx + dy * dy);
   if(dist < minDist) {
    // 如果粒子足够近，则绘制一条线并面对面做弹性运动
    graphics.lineStyle(1, 0xffffff, 1 - dist / minDist);
    graphics.moveTo(partA.x, partA.y);
    graphics.lineTo(partB.x, partB.y);
    // 加速度与距离成正比
    var ax:Number = dx * springAmount;
    var ay:Number = dy * springAmount;
    // 在每个轴上加上加速度
    partA.vx += ax;
    partA.vy += ay;
    partB.vx -= ax;
    partB.vy -= ay;
   }
  }
 }
}
我不去深入解释这段代码。主要就是创建一些粒子，并让它们运动。如果两个粒子间的距离小于特定范围，它们将相互作弹性运动，然后在它们之间绘制一条线。粒子越近，相互作用越大，线条也就越亮。注意，舞台的颜色在类的顶部用 SWF 元数据标签被设置为黑色：
    [SWF(backgroundColor=0x000000)]
这个元数据标签会在 Flex Builder 或 Flash CS4 中起作用，但是 Flash CS3 会忽略它，需要你在属性面板中设置背景颜色。由于我们要使用 Flash 10 的某些新特性，我就假设大家使用的是 Flash CS4 了。

    这个文件同样用到一个类名为 Ball，这个类与前面的有一点点不同，但效果同样不错。

    这个例子使用了 30 个粒子，在 100 像素或更少的距离时产生反作用力。例子本身看起来很好不需要什么改进。下面让我们改变一些参数让它看起来不那么舒服：
    private var numParticles:uint = 500;
    private var misDist:Number = 50;
将粒子的数量增加到 500 个，然后将距离设置为 50。如果你使用 Flash 官方的开发环境，可能需要把舞台的尺寸设置大一点儿才能让这些粒子不那么拥挤——比如 1000 × 800。当运行这个文件的时候，你将感到非常的卡，也许每秒只有几帧。

    现在看看如何让网格级碰撞检测来帮助我们。所有粒子间的循环判断用粗体字标注。这是我们需要用网格替代的部分。这部分要替换成网格，同时还将做一些简单的改进将数组变成向量。如果你很好奇，可以先试一下将 Array 转换为 Vector.<DisplayObject> 对比效率提高了多少。你也需要导入 flash.display.DisplayObject 类，并在使用的时候将对象转换为 Ball 类，如下：
    var particle:Ball = particles[i] as Ball;
在我的测试中，虽然有些改进，但是太小了。500 个对象的双重循环每帧需要 124750 次判断。我们势必要减少这个数量，因为真正可能碰撞的物体比例很小。基于网格的碰撞检测将判次数减少到 10000 以下。下面是代码，在一个新的 NodeGardenGrid 类中（加粗的部分是和前面不同的地方）：
package {
 import flash.display.DisplayObject;
 import flash.display.Sprite;
 import flash.display.StageScaleMode;
 import flash.display.StageAlign;
 import flash.events.Event;
 import flash.geom.Point;

 [SWF(backgroundColor=0x000000)]
 public class NodeGardenGrid extends Sprite {
  private var particles:Vector.<DisplayObject>;
  private var numParticles:uint = 500;
  private var minDist:Number = 50;
  private var springAmount:Number = .001;
  private var grid:CollisionGrid;
  
  public function NodeGardenGrid() {
   init();
  }
  
  private function init():void {
   stage.scaleMode = StageScaleMode.NO_SCALE;
   stage.align = StageAlign.TOP_LEFT;
   
   grid = new CollisionGrid(stage.stageWidth, stage.stageHeight, 50);
   particles = new Vector.<DisplayObject>();
   for(var i:uint = 0; i < numParticles; i++) {
    // 创建所有的粒子
    var particle:Ball = new Ball(3, 0xffffff);
    particle.x = Math.random() * stage.stageWidth;
    particle.y = Math.random() * stage.stageHeight;
    particle.vx = Math.random() * 6 - 3;
    particle.vy = Math.random() * 6 - 3;
    addChild(particle);
    particles.push(particle);
   }
   
   addEventListener(Event.ENTER_FRAME, onEnterFrame);
  }

  private function onEnterFrame(event:Event):void {
   graphics.clear();
   for(var i:uint = 0; i < numParticles; i++) {
    // 更新粒子，包装舞台
    var particle:Ball = particles[i] as Ball;
    particle.x += particle.vx;
    particle.y += particle.vy;
    if(particle.x > stage.stageWidth) {
     particle.x = 0;
    } else if(particle.x < 0) {
     particle.x = stage.stageWidth;
    }
    if(particle.y > stage.stageHeight) {
     particle.y = 0;
    } else if(particle.y < 0) {
     particle.y = stage.stageHeight;
    }
   }
   // 确定哪些粒子需要检测
   grid.check(particles);
   var checks:Vector.<DisplayObject> = grid.checks;
   trace(checks.length);
   var numChecks:int = checks.length;
   for(i=0; i < numChecks; i += 2) {
    var partA:Ball = checks[i] as Ball;
    var partB:Ball = checks[i + 1] as Ball;
    spring(partA, partB);
   }
  }
  
  private function spring(partA:Ball, partB:Ball):void {
   var dx:Number = partB.x - partA.x;
   var dy:Number = partB.y - partA.y;
   var dist:Number = Math.sqrt(dx * dx + dy * dy);
   if(dist < minDist) {
    graphics.lineStyle(1, 0xffffff, 1 - dist / minDist);
    graphics.moveTo(partA.x, partA.y);
    graphics.lineTo(partB.x, partB.y);
    var ax:Number = dx * springAmount;
    var ay:Number = dy * springAmount;
    partA.vx += ax;
    partA.vy += ay;
    partB.vx -= ax;
    partB.vy -= ay;
   }
  }
 }
}
确认你的影片是以 Flash 10 格式发布的，并且 CollisionGrid.as 文件在你的类路径中，这样的结果会是每帧 6500 次。注意网格的大小是 50，与 minDist 相同。这段特别的代码不依赖粒子的半径，只计算它们间的距离。大家最好做一些实时的测试并调整网格的大小直至性能最佳。较大的格子会有更多的碰撞检测，却会减少数组循环次数。通过调整会得到一个最佳性能的平衡点。即使在最小值 50，它的表现也相当不错。

总结
    至此高级碰撞检测就讨论完了。这两种技术（基于位图和网格的碰撞检测）有很多方法可以使用，给大家启蒙的例子中概念不多。同时，最重要的是领悟其中的思想，尤其在基于网格的系统中，就是要测试，测试；考量性能；微调碰撞检测引擎。并且要记住这种方法在物体多的时候表现最佳，但是系统开销要比物体数量更重要。

接下来是一个完全不同的主题，转向行为。我们也将涉及一些人工智能方面的内容。