矩形在as3视觉编程中的几个应用方式

　　矩形在视觉编程中应用甚广，下面描述其中的几种在as3中的应用方式。

　　本文所用的速度用矢量表示,都是Vector_2D类的实例。
　　这个2D的矢量类见 http://www.cnblogs.com/vilyLei/articles/1567703.html

1.一个物体被限制在矩形框内运动，碰到边界就反弹.此处用矩形物体来做示例,此示例代码直接复制即可用作测试。

as3代码如下：

　　

package
{
    /**
      * Copyright (C) 2008-2012 Vily
     *
     * @class name(类名):    Main
     *
     * @author(创建人): Vily
     *
     * @version(版本): v1.1
     *
     * @create date(创建日期): 2009-12-13
     *
     * @purpose(对此类实现的功能的描述):Main文档类
     *
     * @public properties(公开的属性): None. Static constants only.
     * @public methods(公开的方法):
     *             Main( ) - Constructor. 
     *
     */
    import flash.display.Sprite;
    import flash.events.Event;
    import flash.geom.Rectangle;
    
    public class Main extends Sprite{
        //作为矩形区域的矩形块
        private var _areaRectSpr:RectSpr = null;
        //作为运动的矩形块
        private var _currSpr:RectSpr = null;
        //记录物体运动当前速度的矢量
        private var _currV:Vector_2D = new Vector_2D();
        private var _areaRect:Rectangle = null;
        public function Main(){
            init();
        }
        /**
         *    系统程序初始化入口
         */
        private function init():void{
            
            initDispObj();
            initListener();
        }        
        /**
         *    初始化显示对象
         */
        private function initDispObj():void{
            
            //矩形区域
            _areaRect = new Rectangle(50,50,450,300);
            _areaRectSpr = new RectSpr();
            addChild(_areaRectSpr);
            _areaRectSpr.x = _areaRect.x;
            _areaRectSpr.y = _areaRect.y;
            _areaRectSpr.drawBg(_areaRect.width,_areaRect.height);
            
            //运动的矩形可是对象
            _currSpr = new RectSpr();
            _currSpr.drawBg(30,30,0xff0000);
            _currSpr.x = 200;
            _currSpr.y = 200;
            addChild(_currSpr);
            
            _currV.x = Math.round(Math.random() * 4);
            _currV.y = Math.round(Math.random() * 4);
        }
        /**
         *    初始化侦听器
         */
        private function initListener():void{
            this.addEventListener(Event.ENTER_FRAME,enterTest);
        }
        private function enterTest(evt:Event):void{
            
            //检测运动的_currSpr是否碰到矩形的左右边界
            var px:Number = 0;
            if(_currV.x > 0){
                px = _currSpr.x + _currV.x;
                if(px > (_areaRect.x + _areaRect.width - _currSpr.width)){
                    px = _areaRect.x + _areaRect.width - _currSpr.width;
                    _currV.x = -_currV.x;
                }
            }else{
                px = _currSpr.x + _currV.x;
                if(px < _areaRect.x){
                    px = _areaRect.x;
                    _currV.x = -_currV.x;
                }
            }
            
            //检测运动的_currSpr是否碰到矩形的上下边界
            var py:Number = 0;
            if(_currV.y > 0){
                py = _currSpr.y + _currV.y;
                if(py > (_areaRect.y + _areaRect.height - _currSpr.height)){
                    py = _areaRect.y + _areaRect.height - _currSpr.height;
                    _currV.y = -_currV.y;
                }
            }else{
                py = _currSpr.y + _currV.y;
                if(py < _areaRect.y){
                    py = _areaRect.y;
                    _currV.y = -_currV.y;
                }
            }
            _currSpr.x = px;
            _currSpr.y = py;
        }
    }
}

import flash.display.Sprite;
class RectSpr extends Sprite{
    public function RectSpr(){}
    public function drawBg(w:Number,h:Number,color:uint = 0x0):void{
        this.graphics.beginFill(color);
        this.graphics.drawRect(0,0,w,h);
        this.graphics.endFill();
    }
}

 

2.检测是否碰撞到矩形，如果碰到障碍物就反弹(A)

　　本示例 以运动的矩形物体的中心点为检测条件。也就相当于判定一个点是否和一个矩形相碰撞。

　　而碰撞后反弹时的速度矢量则使用逆向算法计算的到.

　　as3代码如下:

package
{
    /**
      * Copyright (C) 2008-2012 Vily
     *
     * @class name(类名):    Main
     *
     * @author(创建人): Vily
     *
     * @version(版本): v1.1
     *
     * @create date(创建日期): 2009-12-13
     *
     * @purpose(对此类实现的功能的描述):Main文档类
     *
     * @public properties(公开的属性): None. Static constants only.
     * @public methods(公开的方法):
     *             Main( ) - Constructor. 
     *
     */
    import flash.display.Sprite;
    import flash.events.Event;
    import flash.geom.Rectangle;
    
    public class Main extends Sprite{
        //作为矩形区域的矩形块
        private var _areaRectSpr:RectSpr = null;
        //作为运动的矩形块
        private var _currSpr:RectSpr = null;
        //记录物体运动当前速度的矢量
        private var _currV:Vector_2D = new Vector_2D();
        //限制小矩形块运动的矩形区域
        private var _areaRect:Rectangle = null;        
        
        //临时矢量
        private var _tempV:Vector_2D = new Vector_2D();
        //矩形障碍物所占的矩形
        private var _blockRect:Rectangle = null;
        //作为矩形障碍物的RectSpr实例
        private var _blockSpr:RectSpr = null;
        public function Main(){
            init();
        }
        /**
         *    系统程序初始化入口
         */
        private function init():void{
            
            initDispObj();
            initListener();
        }        
        /**
         *    初始化显示对象
         */
        private function initDispObj():void{
            
            //矩形区域
            _areaRect = new Rectangle(50,50,450,300);
            _areaRectSpr = new RectSpr();
            addChild(_areaRectSpr);
            _areaRectSpr.x = _areaRect.x;
            _areaRectSpr.y = _areaRect.y;
            _areaRectSpr.drawBg(_areaRect.width,_areaRect.height);
            
            
            //矩形障碍物
            _blockRect = new Rectangle(240,120,80,150);
            _blockSpr = new RectSpr();
            addChild(_blockSpr);
            _blockSpr.x = _blockRect.x;
            _blockSpr.y = _blockRect.y;
            _blockSpr.drawBg(_blockRect.width,_blockRect.height,0x008800);
            
            //运动的矩形可是对象
            _currSpr = new RectSpr();
            _currSpr.drawBg(30,30,0xff0000);
            _currSpr.x = 81;
            _currSpr.y = 81;
            addChild(_currSpr);
            
            _currV.x = Math.round(Math.random() * 4);
            _currV.y = Math.round(Math.random() * 4);
        }
        /**
         *    初始化侦听器
         */
        private function initListener():void{
            this.addEventListener(Event.ENTER_FRAME,enterTest);
        }
        //计算碰到矩形边界后的速度矢量
        protected function calcHitRectBoundsV(posV:Vector_2D,speed_v:Vector_2D,rect:Rectangle):Boolean{
            var px:Number = posV.x + speed_v.x;
            if(px <= rect.x || px >= (rect.x + rect.width)){
                //碰到左边界
                speed_v.x = -speed_v.x;
                return true;
            }
            var py:Number = posV.y + speed_v.y;
            if(py <= rect.y || py >= (rect.y + rect.height)){
                    //碰到左边界
                    speed_v.y = -speed_v.y;
                    return true;                
            }
            return false;
        }
        private function enterTest(evt:Event):void{
            
            var py:Number = 0;
            var px:Number = 0;
            //检测是否碰到障碍物
            //计算_currSpr下一步运动后的中心点坐标
            _tempV.x = _currSpr.x + _currSpr.width/2 + _currV.x;
            _tempV.y = _currSpr.y + _currSpr.height/2 + _currV.y;
            //先判断小矩形块的中心点是否和矩形障碍物相碰
            if(_blockRect.contains(_tempV.x,_tempV.y)){
                
                //这里采用逆向算法来计算碰撞后的速度矢量
                _currV.x = -_currV.x;
                _currV.y = -_currV.y;
                var boo:Boolean = calcHitRectBoundsV(_tempV,_currV,_blockRect);
                _currV.x = -_currV.x;
                _currV.y = -_currV.y;
                
                //如果已经碰撞，那就要反弹.
                if(boo){
                    return;
                }
            }
            
            //检测运动的_currSpr是否碰到矩形的左右边界            
            if(_currV.x > 0){
                px = _currSpr.x + _currV.x;
                if(px > (_areaRect.x + _areaRect.width - _currSpr.width)){
                    px = _areaRect.x + _areaRect.width - _currSpr.width;
                    _currV.x = -_currV.x;
                }
            }else{
                px = _currSpr.x + _currV.x;
                if(px < _areaRect.x){
                    px = _areaRect.x;
                    _currV.x = -_currV.x;
                }
            }
            
            //检测运动的_currSpr是否碰到矩形的上下边界            
            if(_currV.y > 0){
                py = _currSpr.y + _currV.y;
                if(py > (_areaRect.y + _areaRect.height - _currSpr.height)){
                    py = _areaRect.y + _areaRect.height - _currSpr.height;
                    _currV.y = -_currV.y;
                }
            }else{
                py = _currSpr.y + _currV.y;
                if(py < _areaRect.y){
                    py = _areaRect.y;
                    _currV.y = -_currV.y;
                }
            }            
            _currSpr.x = px;
            _currSpr.y = py;
        }
    }
    
    
}

import flash.display.Sprite;
class RectSpr extends Sprite{
    public function RectSpr(){}
    public function drawBg(w:Number,h:Number,color:uint = 0x0):void{
        this.graphics.beginFill(color);
        this.graphics.drawRect(0,0,w,h);
        this.graphics.endFill();
    }
}

 

 

3.检测是否碰撞到矩形，如果碰到障碍物就反弹(B)

　　本示例 以运动的矩形物体所占据的矩形区域为检测条件。也就相当于判定两个矩形相的碰撞。

　　而碰撞后反弹时的速度矢量则使用矩形重叠算法计算的到.

 

package
{
    /**
      * Copyright (C) 2008-2012 Vily
     *
     * @class name(类名):    Main
     *
     * @author(创建人): Vily
     *
     * @version(版本): v1.1
     *
     * @create date(创建日期): 2009-12-13
     *
     * @purpose(对此类实现的功能的描述):Main文档类
     *
     * @public properties(公开的属性): None. Static constants only.
     * @public methods(公开的方法):
     *             Main( ) - Constructor. 
     *
     */
    import flash.display.Sprite;
    import flash.events.Event;
    import flash.geom.Rectangle;
    
    public class Main extends Sprite{
        //作为矩形区域的矩形块
        private var _areaRectSpr:RectSpr = null;
        //作为运动的矩形块
        private var _currSpr:RectSpr = null;
        //记录物体运动当前速度的矢量
        private var _currV:Vector_2D = new Vector_2D();
        //限制小矩形块运动的矩形区域
        private var _areaRect:Rectangle = null;        
        
        //临时矢量
        private var _tempV:Vector_2D = new Vector_2D();
        //临时矩形变量
        private var _tempRect:Rectangle = new Rectangle();
        private var _interRect:Rectangle = null;
        
        //矩形障碍物所占的矩形
        private var _blockRect:Rectangle = null;
        //作为矩形障碍物的RectSpr实例
        private var _blockSpr:RectSpr = null;
        public function Main(){
            init();
        }
        /**
         *    系统程序初始化入口
         */
        private function init():void{
            
            initDispObj();
            initListener();
        }        
        /**
         *    初始化显示对象
         */
        private function initDispObj():void{
            
            //矩形区域
            _areaRect = new Rectangle(50,50,450,300);
            _areaRectSpr = new RectSpr();
            addChild(_areaRectSpr);
            _areaRectSpr.x = _areaRect.x;
            _areaRectSpr.y = _areaRect.y;
            _areaRectSpr.drawBg(_areaRect.width,_areaRect.height);
            
            
            //矩形障碍物
            _blockRect = new Rectangle(240,120,80,150);
            _blockSpr = new RectSpr();
            addChild(_blockSpr);
            _blockSpr.x = _blockRect.x;
            _blockSpr.y = _blockRect.y;
            _blockSpr.drawBg(_blockRect.width,_blockRect.height,0x008800);
            
            //运动的矩形可是对象
            _currSpr = new RectSpr();
            _currSpr.drawBg(30,30,0xff0000);
            _currSpr.x = 81;
            _currSpr.y = 81;
            addChild(_currSpr);
            
            _currV.x = Math.round(Math.random() * 4);
            _currV.y = Math.round(Math.random() * 4);
            _tempRect.width = _currSpr.width;
            _tempRect.height = _currSpr.height;
        }
        /**
         *    初始化侦听器
         */
        private function initListener():void{
            this.addEventListener(Event.ENTER_FRAME,enterTest);
        }        
        private function enterTest(evt:Event):void{
            
            var py:Number = 0;
            var px:Number = 0;
            
            //计算_currSpr下一步运动后的矩形数据
            _tempRect.x = _currSpr.x + _currV.x;
            _tempRect.y = _currSpr.y + _currV.y;
            //判断小矩形块是否和矩形障碍物相碰,如果相碰就反弹
            _interRect = _tempRect.intersection(_blockRect);
            if(_interRect.width>0 || _interRect.height>0 ){
                if(_interRect.width < _interRect.height){
                        _currV.x = -_currV.x;
                }else{
                    _currV.y = -_currV.y;
                }
                return;
            }
            
            //检测运动的_currSpr是否碰到矩形的左右边界
            if(_currV.x > 0){
                px = _currSpr.x + _currV.x;
                if(px > (_areaRect.x + _areaRect.width - _currSpr.width)){
                    px = _areaRect.x + _areaRect.width - _currSpr.width;
                    _currV.x = -_currV.x;
                }
            }else{
                px = _currSpr.x + _currV.x;
                if(px < _areaRect.x){
                    px = _areaRect.x;
                    _currV.x = -_currV.x;
                }
            }
            
            //检测运动的_currSpr是否碰到矩形的上下边界            
            if(_currV.y > 0){
                py = _currSpr.y + _currV.y;
                if(py > (_areaRect.y + _areaRect.height - _currSpr.height)){
                    py = _areaRect.y + _areaRect.height - _currSpr.height;
                    _currV.y = -_currV.y;
                }
            }else{
                py = _currSpr.y + _currV.y;
                if(py < _areaRect.y){
                    py = _areaRect.y;
                    _currV.y = -_currV.y;
                }
            }            
            _currSpr.x = px;
            _currSpr.y = py;
        }
    }
    
    
}

import flash.display.Sprite;
class RectSpr extends Sprite{
    public function RectSpr(){}
    public function drawBg(w:Number,h:Number,color:uint = 0x0):void{
        this.graphics.beginFill(color);
        this.graphics.drawRect(0,0,w,h);
        this.graphics.endFill();
    }
}

  

注意，在实际的应用中可能需要第二点和第三点结合使用。否则可能有偏差。

以上描述如果有问题，请您留言提示我，在此先谢谢了。