actionscript3 常用类库

//======================================
////////////////////////////////////////

//扩展Math函数 

////////////////////////////////////////
//======================================



package cn.flashOpen.kit ...{

import flash.display.Sprite;
import flash.display.MovieClip;
import flash.geom.Point;


    public class ExtMath
    ...{
        
        //坐标转换
        //car2Flash//迪卡尔坐标转成Flash坐标
        public static function car2Flash(_mc) 
        ...{
            _mc.y = _mc.y * -1;
            _mc.rotation = _mc.rotation * -1;
        }
        
        
        
        //flash2Car//Flash坐标转成迪卡尔坐标
        public static function flash2Car (_mc) 
        ...{
            return (car2Flash(_mc));
        }
        
        
        
        //car2Polar//迪卡尔坐标转成极坐标
        public static function car2Polar (x:Number, y:Number) 
        ...{
            var len:Number = Math.sqrt((x * x) + (y * y));
            var ang:Number = atan2D(y, x);
            return (...{r:len, a:ang});
        }
        
        
        
        //polar2Car//极坐标转成迪卡尔坐标
        public static function polar2Car (len:Number, ang:Number) 
        ...{
            var xx:Number = len * cosD(ang);
            var yy:Number = len * sinD(ang);
            return (...{x:xx, y:yy});
        }
        
        
        
        //getMcCoordG//获得本身全局坐标
        public static function getMcCoordG (_mc)
        ...{
            //_mc为要获得坐标的影片,他的坐标系影片为：_mc.parent;
            var p:Point = new Point(_mc.x, _mc.y);
            p = _mc.parent.localToGlobal(p);
            return p;
        }
        
        
        
        //getCoordG//获得影片全局坐标
        public static function getCoordG (_mc, _xx:Number, _yy:Number)
        ...{
            //_mc要xx,yy所在坐标系的影片(若xx = myMc.x,则坐标系影片为：myMc.parent)
            var p:Point = new Point(_xx, _yy);
            p = _mc.localToGlobal(p);
            return p;
        }
        
        
        //getCoordL//获得影片本地坐标
        public static function getCoordL (_mc, _xx:Number, _yy:Number)
        ...{
            //_mc要xx,yy要转入的坐标系的影片
            var p:Point = new Point(_xx, _yy);
            p = _mc.parent.globalToLocal(p);
            return p;
        }
        
        
        //mc2McCoord//转换成特定影片的坐标
        public static function mc2McCoord (_mc1, _mc2, _xx, _yy)
        ...{
            //mc1为_xx,_yy所在的坐标系影片，_mc2为要转入的坐标系影片
            var p:Point = new Point(_xx, _yy);
            p = _mc1.localToGlobal(p);
            p = _mc2.parent.globalToLocal(p);
            return p;
        }
        
        
        
        
        
        
        
        
        //数学函数
        
        
        //标签
        //getRand//获得随机数
        static function getRand(_nStartNum:Number, _nEndNum:Number, _nDecimalDigits:Number)
        ...{
            var nRange = _nEndNum - _nStartNum;
            var nRand = _nStartNum + Math.random() * nRange;
            var nScale = Math.pow(10, _nDecimalDigits);
            nRand = Math.floor(nRand * nScale)/nScale;
            
            return nRand;
        }
        
    
        //randPole//获得随机正负标签
        public static function randPole ()
        ...{
            var nPole:Number = Math.random() > 0.5 ? 1:-1;
            return nPole;
        }
        
        
        //intRand//获得随机向下取整的整数
        public static function intRand (_n:Number)
        ...{
            var n:Number = Math.floor(Math.random() * _n);
            return n;
        }
        
        
        //intCeil//获得随机向上取整的整数
        public static function ceilRand (_n:Number)
        ...{
            var n:Number = Math.ceil(Math.random() * _n);
            return n;
        }
        
        
        
        
        
        //距离
        //getDis//获得距离
        public static function getDis (_x1:Number, _y1:Number, _x2:Number, _y2:Number)
        ...{
            var dx:Number = _x2 - _x1;
            var dy:Number = _y2 - _y1;
            var L:Number = Math.sqrt(dx * dx + dy * dy);
            return L;
        }
        
        
        
        //getL2//获得三角形短边
        public static function getL2 (_l1:Number, _l3:Number)
        ...{
            //_l1为短边， _l3为长边
            var l2:Number = Math.sqrt(_l3 * _l3 - _l1 * _l1);
            return l2;
        }
        
        
        
        //getL3//获得三角形长边
        public static function getL3 (_l1:Number, _l2:Number)
        ...{
            //_l1，_l2为短边
            var l3:Number = Math.sqrt(_l1 * _l1 + _l2 * _l2);
            return l3;
        }
        
        
        
        
        
        //三角函数 
        
        //正函数
        //sinD
        public static function sinD (_ang:Number)
        ...{
            var n:Number = Math.sin(_ang * 3.141593 / 180);
            return n;
        }
        
        
        
        //cosD
        public static function cosD (_ang:Number)
        ...{
            var n:Number = Math.cos(_ang * 3.141593 / 180);
            return n;
        }
        
        
        
        //tanD
        public static function tanD (_ang:Number)
        ...{
            var n:Number = Math.tan(_ang * 3.141593 / 180);
            return n;
        }
        
        
        
        
        //反函数
        //asinD
        public static function asinD (_ratio:Number)
        ...{
            var n:Number = Math.asin(_ratio) * 57.295780;
            return n;
        }
        
        
        
        //acosD
        public static function acosD (_ratio:Number)
        ...{
            var n:Number = Math.acos(_ratio) * 57.295780;
            return n;
        }
        
        
        
        //atan2D
        public static function atan2D (y:Number, x:Number)
        ...{
            var ang:Number = Math.atan2(y, x) * 57.295780;
            return ang;
        }
        
        
        
        
        
        //角度操作
        //d2r
        public static function d2r (_ang:Number)
        ...{
            var radian:Number = _ang * 0.017453;
            return radian;
        }
        
        
        
        //d2r
        public static function r2d (_radian:Number)
        ...{
            var ang:Number = _radian * 57.295780;
            return ang;
        }
        
        
        
        //fixAngle//标准化角度
        public static function fixAng (_ang:Number)
        ...{
            var _ang:Number = _ang % 360;
            var ang:Number = _ang % 360 < 0 ? _ang + 360 : _ang;
            return ang;
        }
        
        
        
        //getAngle//获得角度
        public static function getAng (_x1:Number, _y1:Number, _x2:Number, _y2:Number)
        ...{
            var ang:Number = Math.atan2(_y2 - _y1, _x2 - _x1) * 57.295780;
            return ang;
        }
        
        
        
        //getClampAng/获得夹角
        public static function getClampAng (_a1:Number, _a2:Number)
        ...{
            var a1:Number = fixAng(_a1);
            var a2:Number = fixAng(_a2);
            
            var dAng:Number = Math.abs(a2 - a1);
            
            if(dAng > 180) dAng = 360 - dAng;
            dAng = fixAng(dAng);
            
            return dAng;
        }
        
        
        
        //getOutAng/获得出射角
        public static function getOutAng (_lineAng:Number, _inAng:Number)
        ...{
            //_lineAng为水平线的角度， _inAng为入射角度
            var outAng:Number = _lineAng * 2 - _inAng;
            return outAng;
        }
        
        
        
        //getTrendRo//获得趋近角度
        public static function getTrendRo (_oAng:Number, _aimAng:Number, _trandRate:Number, _minAng:Number)
        ...{
            //_oAng为原角度，_aimAng为目标角度
            //_rate < 1时为_aimAng和_oAng夹角的趋近比率,_rate>1时为每次改变的角度
            //_minAng为执行的最小角度
            
            var dAng:Number = fixAng(_aimAng - _oAng);
            var absDAng:Number = Math.abs(dAng);
            var minAng:Number = !_minAng ? 0 : _minAng;
            
            if(absDAng <= minAng) return _oAng;
            
            var pole:Number;
            
            if(absDAng > 180)
            ...{
                absDAng = 360 - absDAng;
                pole = -absDAng/dAng;
            }
            else
            ...{
                pole = absDAng/dAng;
            }
            
            var newAng:Number;
            
            if(_trandRate < 1)
            newAng = _oAng + pole * absDAng * _trandRate;
            else
            newAng = _oAng + pole * _trandRate;
            
            return newAng;
        }
        
        
        
        //classRo//经典旋转
        public static function classRo  (_xx:Number,_yy:Number,_ang:Number,_ox:Number,_oy:Number)
        ...{
            //_xx,_yy为要旋转的点坐标，_ang为要旋转的角度，
            //_ox,_oy为旋转中心点
            
            var x:Number = _xx;
            var y:Number = _yy;
            var ang:Number = _ang;
            var ox:Number = _ox;
            var oy:Number = _oy;
            
            x -= ox;
            y -= oy;
            
            var x1:Number = cosD(ang) * x - sinD(ang) * y;
            var y1:Number = cosD(ang) * y + sinD(ang) * x;
            
            x1 += ox;
            y1 += oy;
            
            return ...{x:x1,y:y1};
        }
        
        
        
        //mcRo//影片旋转
        public static function mcRo (_mc, _xx:Number, _yy:Number, _offsetAng:Number)
        ...{
            //_mc为要旋转的影片,_xx为目标x坐标，_yy为目标y坐标，_offsetAng为偏移角度
            
            var x:Number = _xx - _mc.x;
            var y:Number = _yy - _mc.y;
            var ang:Number = atan2D(y,x);
            
            if(_mc)
            ...{
                if(!_offsetAng) _offsetAng = 0;
                ang += _offsetAng;
            }
            
            return ang;
        }
        
        
        
        
        //oddsManage//几率管理
        public static function oddsManage (_mc, _aOdds:Array, _aFun:Array)
        ...{
            var len:Number = _aOdds.length;
            var nRand:Number = Math.random();
            var id:Number = 0;
            
            
            for(var i=0; i<len; i++)
            ...{
                var rate1:Number = 0;
                var rate2:Number = _aOdds[i];
                
                
                for(var j=0; j<i; j++)
                ...{
                    rate1 += _aOdds[j];
                }
                
                
                rate2 +=  rate1;
                

                if(nRand >= rate1)
                ...{
                    if(nRand < rate2)
                    ...{
                        id = i;
                        break;
                    }
                }
                
            }
            
            return _mc[_aFun[id]]();
        }
    }
}