Artificial intelligence 创造敌人的视野

我试图为我的敌人创造一个圆锥体。现在，它会检查玩家是否在半径范围内，然后再向他们移动，如果不在半径范围内，它会随机移动。我想给它一个视野，这样敌人就不会总是朝着玩家旋转

敌级

package 
{
    import flash.automation.ActionGenerator;
    import flash.events.Event;
    import flash.geom.Point;

    public class Enemy extends GameObject
    {

        var isDead:Boolean = false;

        var speed:Number = 3;

        var originalValue:Number = 50;

        var changeDirection:Number = originalValue;



        var checkDirection:Number = 49;

        var numberGen:Number;

        //var startTime:int = getTimer();

        //var $timer = getTimer();

        //var myTimer:int = getTimer();
        //var moveTimer:int = timer - $timer;

        public function Enemy()
        {
            super();
            target = target_mc;
        }

        override public function update():void
        {
            movement();

        }

        private function movement():void
        {
            if (changeDirection >= 0)
            {                   
                if (changeDirection > checkDirection)
                {
                    numberGen = (Math.random() * 360) / 180 * Math.PI;

                }

                var velocity:Point = new Point();
                var $list:Vector.<GameObject >  = getType(Player);

                var $currentDistance:Number = Number.MAX_VALUE;
                for (var i:int = 0; i < $list.length; i++)
                {
                    var currentPlayer:GameObject = $list[i];
                    if (MathUtil.isWithinRange(currentPlayer.width,currentPlayer.x,currentPlayer.y,width,x,y))
                    {
                        var $delta:Point = new Point  ;
                        $delta.x = currentPlayer.x - x;
                        $delta.y = currentPlayer.y - y;
                        if ($currentDistance > $delta.length)
                        {
                            $currentDistance = $delta.length;
                            velocity = $delta;
                            velocity.normalize(speed);
                        }
                    }
                }
                if(velocity.length == 0)
                    {
                        velocity = Point.polar(2, numberGen);
                    }

                    changeDirection--;

                    if (changeDirection == 0)
                    {
                        changeDirection = originalValue;
                    }
            }

            velocity.x = Math.floor(velocity.x * 10) * .1;
            velocity.y = Math.floor(velocity.y * 10) * .1;


            moveBy([Wall, Door], velocity.x, velocity.y, collides_mc);

            var $collides:GameObject = collision([Player]);
            if ($collides != null)
            {
                destroy();
            }

            if ($collides == null)
            {
                $collides = collision([Player],this);
                if ($collides != null)
                {
                    $collides.destroy();
                }
            }

            rotation = (Math.atan2(velocity.y, velocity.x) * 180 / Math.PI);
            collides_mc.rotation = -rotation;

            trace($collides);

        }

        override public function onCollideX($collision:GameObject):void
        {

        }

        override public function onCollideY($collision:GameObject):void
        {

        }

    }

}

包
{
进口flash.automation.ActionGenerator；
导入flash.events.Event；
导入flash.geom.Point；
公共类敌人扩展游戏对象
{
var isDead:Boolean=false；
var速度：数字=3；
var原始值：数值=50；
var changeDirection：数字=原始值；
var检查方向：数字=49；
var numberGen：数字；
//var startTime:int=getTimer（）；
//var$timer=getTimer（）；
//var myTimer:int=getTimer（）；
//var moveTimer:int=timer-$timer；
公共职能（）
{
超级（）；
target=target_mc；
}
重写公共函数更新（）：void
{
运动（）；
}
私有函数移动（）：void
{
如果（更改方向>=0）
{                   
如果（更改方向>检查方向）
{
numberGen=（Math.random（）*360）/180*Math.PI；
}
变量速度：点=新点（）；
var$list:Vector.=getType（播放器）；
var$currentDistance:Number=Number.MAX_值；
对于（变量i:int=0；i<$list.length；i++）
{
var currentPlayer:GameObject=$list[i]；
if（MathUtil.isWithinRange（currentPlayer.width，currentPlayer.x，currentPlayer.y，width，x，y））
{
变量$delta:Point=新点；
$delta.x=currentPlayer.x-x；
$delta.y=currentPlayer.y-y；
如果（$currentDistance>$delta.length）
{
$currentDistance=$delta.length；
速度=$delta；
速度。标准化（速度）；
}
}
}
如果（velocity.length==0）
{
速度=极坐标点（2，数字）；
}
改变方向--；
if（changeDirection==0）
{
变更方向=原始值；
}
}
velocity.x=数学地板（velocity.x*10）*.1；
velocity.y=数学地板（velocity.y*10）*.1；
moveBy（[Wall，Door]，velocity.x，velocity.y，collides_mc）；
var$collides:GameObject=碰撞（[Player]）；
如果（$collides！=null）
{
破坏（）；
}
如果（$collides==null）
{
$collides=碰撞（[Player]，this）；
如果（$collides！=null）
{
$collides.destroy（）；
}
}
旋转=（数学atan2（速度y，速度x）*180/数学PI）；
碰撞_mc.rotation=-旋转；
跟踪（碰撞）；
}
覆盖公共函数onCollideX（$collision:GameObject）：无效
{
}
覆盖公共函数onCollideY（$collision:GameObject）：无效
{
}
}
}

GameObject类，包含所有函数并扩展它

package
{
    import flash.display.DisplayObject;
    import flash.events.Event;
    import flash.ui.Keyboard;
    import flash.events.KeyboardEvent;
    import flash.display.MovieClip;
    import flash.display.Sprite;
    import flash.sensors.Accelerometer;
    import flashx.textLayout.elements.ListElement;

    public class GameObject extends MovieClip
    {

        static public var list:Vector.<GameObject> = new Vector.<GameObject>;
        protected var hitBox:Sprite;

        public var target:MovieClip;        

        public function GameObject()
        {
            target=this;
            list.push(this);
        }

        public function update():void
        {

        }

        public function collision(typesColliding:Array, $target:DisplayObject = null):GameObject
        {
            if($target == null)
                $target = target;

            for (var i:int = list.length - 1; i >= 0; i--)
            {
                var item:GameObject = list[i], found:Boolean = false;

                for (var f:int = typesColliding.length - 1; f >= 0; f--)
                {
                    if (item is typesColliding[f])
                    {
                        found = true;
                        break;
                    }
                }

                if (found && $target.hitTestObject(item.target) && this != item)
                {
                    return item;
                }
            }
            return null;
        }

        public function moveBy(typesColliding:Array, $x:Number = 0, $y:Number = 0, $target:DisplayObject = null):void
        {
            var $collision:GameObject;
            x += $x;
            if (($collision = collision(typesColliding, $target)) != null)
            {
                x -= $x;
                onCollideX($collision);
            }

            y += $y;
            if (($collision = collision(typesColliding, $target)) != null)
            {
                y -= $y;
                onCollideY($collision);
            }
        }

        public function onCollideX($collision:GameObject):void 
        {

        }

        public function onCollideY($collision:GameObject):void 
        {

        }

        public function getType($class:Class):Vector.<GameObject>
        {
            var $list:Vector.<GameObject> = new Vector.<GameObject>;

            for (var i:int = 0; i < list.length; i++)
            {
                if (list[i] is $class)
                {
                    $list.push(list[i]);
                }
            }

            return $list;
        }

        public function destroy():void
        {
            var indexOf:int = list.indexOf(this);
            if (indexOf > -1)
                list.splice(indexOf, 1);

            if (parent)
                parent.removeChild(this);

            trace("removing item: "+this+" list: " + list.length + ": " + list);
        }
    }

}

包
{
导入flash.display.DisplayObject；
导入flash.events.Event；
导入flash.ui.Keyboard；
导入flash.events.KeyboardEvent；
导入flash.display.MovieClip；
导入flash.display.Sprite；
进口闪光传感器、加速度计；
导入flashx.textLayout.elements.ListElement；
公共类游戏对象扩展MovieClip
{
静态公共变量列表：向量。=新向量。；
受保护的var-hitBox:Sprite；
公共风险价值目标：MovieClip；
公共函数GameObject（）
{
目标=这个；
列表。推（这个）；
}
公共函数更新（）：void
{
}
公共函数冲突（类型冲突：数组，$target:DisplayObject=null）：游戏对象
{
如果（$target==null）
$target=目标；
对于（变量i:int=list.length-1；i>=0；i--）
{
变量项：GameObject=list[i]，发现：Boolean=false；
对于（变量f:int=typesColliding.length-1；f>=0；f--）
{
如果（项目为类型冲突[f]）
{
发现=真；
打破
}
}
if（找到&&$target.hitTestObject（item.target）&&this！=项）
{
退货项目；
}
}
返回null；
}
公共函数moveBy（类型包括：数组，$x:Number=0，$y:Number=0，$target:DisplayObject=null）：无效
{
var$collision：游戏对象；
x+=$x；
if（（$collision=collision（typesColliding，$target））！=null）
{
x-=$x；
onCollideX（$碰撞）；
}
y+=$y；
if（（$collision=collision（typesColliding，$target））！=null）
{
y-=$y；
onCollideY（$碰撞）；
}
}
公共函数onCollideX（$collision:GameObject）：无效
{
}
公共函数onCollideY（$collision:GameObject）：无效
{
}
公共函数getType（$class:class）：向量。
{
变量$list:Vector.=新向量。；
对于（变量i:int=0；i