Flex高级动画教程中所讲的寻找行为

----向量类

package vector.steering 

{

    import flash.display.Graphics;

   

    /**

     * ...

     * @author DefaultUser (Tools -> Custom Arguments...)

     */

    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);

        }

        /**

         * 返回自己的克隆向量

         * @return Vector2D

         */

        public function clone():Vector2D {

            return new Vector2D(_x, _y);

        }

        /**

         * 返回 Vector2D (0,0)

         * @return Vector2D

         */

        public function zero():Vector2D {

            _x = 0;

            _y = 0;

            return this;

        }

        /**

         * 返回是否为零向量

         * @return Boolean

         */

        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 = value;

            _x = Math.cos(value) * len;

            _y = Math.sin(value) * len;

        }

        public function get angle():Number {

            return Math.atan2(_y, _x);

        }

        /**

         * 返回垂直向量

         */

        public function get perp():Vector2D {

            return new Vector2D( -y, x);

        }

        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;

        }

        /**

         * 向量单位化

         * @return Vector2D

         */

        public function normalize():Vector2D {

            if (length == 0) {

                _x = 1;

                return this;

            }

            var len:Number = length;

            _x /= len;

            _y /= len;

           

            return this;

        }

        public function scale(value:uint):Vector2D {

           

            return new Vector2D(_x * value, _y * value);

        }

        /**

         * 限制向量的最大长度

         * @param   max

         * @return Vector2D

         */

        public function truncate(max:Number):Vector2D {

            length = Math.min(max, length);

            return this;

        }

        /**

         * 向量反转

         * @return Vector2D

         */

        public function reverse():Vector2D {

            _x = -_x;

            _y = -_y;

           

            return this;

        }

        /**

         * 返回是否为单位向量

         * @return Boolean

         */

        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;

        }

        /**

         * 返回两个向量的角度

         * @param   v1

         * @param   v2

         * @return Number

         */

        public 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));

        }

        /**

         *

         * @param   v2

         * @return Vector2D

         */

        public function sign(v2:Vector2D):int {

            return perp.dotProd(v2) < 0? -1:1;

        }

        /**

         * 返回两个Vector2D之间的距离

         * @param   v2

         * @return Number

         */

        public function dist(v2:Vector2D):Number {

            return Math.sqrt(distSQ(v2));

        }

        /**

         * 返回向量的平方值

         * @param   v2

         * @return Number

         */

        public function distSQ(v2:Vector2D):Number {

            var dx:Number = v2.x - x;

            var dy:Number = v2.y - y;

            return dx * dx + dy * dy;

        }

        /**

         * 加上向量v2

         * @param   v2

         * @return Vector2D

         */

        public function add(v2:Vector2D):Vector2D {

            return new Vector2D(_x + v2.x, _y + v2.y);

        }

        /**

         * 减去向量v2

         * @param   v2

         * @return Vector2D

         */

        public function substract(v2:Vector2D):Vector2D {

            return new Vector2D(_x - v2.x, _y - v2.y);

        }

        /**

         * 乘以向量value

         * @param   value

         * @return Vector2D

         */

        public function multiply(value:Number):Vector2D {

            return new Vector2D(_x * value, _y * value);

        }

        /**

         * 除以向量value

         * @param   value

         * @return Vector2D

         */

        public function divide(value:Number):Vector2D {

            return new Vector2D(_x/value,_y/value);

        }

        /**

         * 判断两个向量是否相同

         * @param   v2

         * @return

         */

        public function equals(v2:Vector2D):Boolean {

            return _x == v2.x && _y == v2.y;

        }

        public function toString():String {

            return "[Vector2D(x:" + _x + ",y:" + _y + ")]";

        }

    }

}

 

----vehicle基类

package vector.steering

{

    import flash.display.Sprite;

   

    public class Vehicle extends Sprite

    {

        protected var _edgeBehavior:String = WRAP;

        protected var _mass:Number = 1.0; //质量

        protected var _maxSpeed:Number = 10;

        protected var _position:Vector2D; //位置向量

        protected var _velocity:Vector2D; //速度向量

       

        public static const WRAP:String = "wrap";

        public static const BOUNCE:String = "boounce";

       

        public function Vehicle(){

            _position = new Vector2D();

            _velocity = new Vector2D();

            draw();

        }

       

        protected function draw():void{

            graphics.clear();

            graphics.lineStyle(0);

            graphics.moveTo(10, 0);

            graphics.lineTo(-10, 5);

            graphics.lineTo(-10, -5);

            graphics.lineTo(10, 0);

        }

       

        public function update():void{

            _velocity.truncate(_maxSpeed);  //限制最大速度

            _position = _position.add(_velocity);   //添加速度向量

           

            if(_edgeBehavior == WRAP){

                wrap();

            }else if(_edgeBehavior == BOUNCE){

                bounce();

            }

           

            //更新机车类坐标

            x = position.x;

            y = position.y;

           

            //更新转向速度

            rotation = _velocity.angle * 180/Math.PI;

        }

       

        /**

         * 碰到墙壁，反弹

         * 直接更改相反方向的向量坐标

         */

        public function bounce():void{

            if(stage != null){

                if(position.x > stage.stageWidth){

                    position.x = stage.stageWidth;

                    velocity.x *= -1;

                }else if(position.x < 0){

                    position.x = 0;

                    velocity.x *= -1;

                }

               

                if(position.y > stage.stageHeight){

                    position.y = stage.stageHeight;        

                    velocity.y *= -1;

                } else if(position.y < 0) {

                    position.y = 0;

                    velocity.y *= -1;

                }

            }

        }

       

        public function wrap():void{

            if(stage != null){

                if(position.x > stage.stageWidth) position.x = 0;

                if(position.x < 0) position.x = stage.stageWidth;

                if(position.y > stage.stageHeight) position.y = 0;

                if(position.y < 0) position.y = stage.stageHeight;

            }

        }

       

       

        public function set edgeBehavior(value:String):void{

            _edgeBehavior = value;

        }

       

        public function get edgeBehavior():String{

            return _edgeBehavior;

        }

       

        public function set mass(value:Number):void{

            _mass = value;

        }

       

        public function get mass():Number{

            return _mass;

        }

       

        public function set maxSpeed(value:Number):void{

            _maxSpeed = value;

        }

       

        public function get maxSpeed():Number{

            return _maxSpeed;

        }

       

        public function set position(value:Vector2D):void{

            _position = value;

            x = _position.x;

            y = _position.y;

        }

       

        public function get position():Vector2D{

            return _position;

        }

       

        public function set velocity(value:Vector2D):void{

            _velocity = value;

        }

       

        public function get velocity():Vector2D{

            return _velocity;

        }

       

        override public function set x(value:Number):void{

            super.x = value;

            _position.x = x;

        }

       

        override public function set y(value:Number):void{

            super.y = value;

            _position.y = y;

        }

    }

}

 

----SteeredVehicle机车子类

package vector.steering

{

    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();

        }

       

        /**

         * 寻找行为 把机车移动到指定点

         */

        public function seek(target:Vector2D):void{

            var desiredVelocity:Vector2D = target.substract(_position);

            desiredVelocity.normalize();

            desiredVelocity = desiredVelocity.multiply(_maxSpeed);

            var force:Vector2D = desiredVelocity.substract(_velocity);

            _steeringForce = _steeringForce.add(force);

           

        }

    }

}

 

---测试类

package vector.chapter1

{

    import flash.display.Sprite;

    import flash.display.StageAlign;

    import flash.display.StageScaleMode;

    import flash.events.Event;

   

    import vector.steering.SteeredVehicle;

    import vector.steering.Vector2D;

   

    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();

        }

    }

}