package {
    import flash.display.Sprite;
    import flash.display.StageAlign;
    import flash.display.StageScaleMode;
    import flash.events.MouseEvent;
    import flash.text.TextField;
    import fl.controls.Slider;
    import flash.utils.getTimer;
    import fl.events.SliderEvent;
 
    public class GridCollisionAdjust extends Sprite {
 
        private const GRID_SIZE:Number=20;//单元格大小(这里设置为小于的直径，即正好容纳一个小球)
        private const RADIUS:Number=10;//小球的半径
        private var _balls:Array;
        private var _grid:Array;
        private var _numBalls:int=50;//小球数量
        private var _txtGrid:TextField = new TextField();
        private var _txtBasic:TextField = new TextField();
        private var _slider:Slider = new Slider();
 
        public function GridCollisionAdjust() {
            stage.align=StageAlign.TOP_LEFT;
            stage.scaleMode=StageScaleMode.NO_SCALE;
 
            makeGrid();
            drawGrid();
 
            addChild(_slider);
            addChild(_txtGrid);
            addChild(_txtBasic);
 
            test();
 
            _slider.addEventListener(SliderEvent.THUMB_DRAG,sliderGrag);
            stage.addEventListener(MouseEvent.CLICK,stageClick);
 
        }
 
        private function test(isClear:Boolean=false):void {
            var i:int=0;
            if (isClear) {
                for (i=numChildren-1; i>=0; i--) {
                    removeChild(getChildAt(i));
                }
                _balls.length=0;
            }
            _txtGrid.background=_txtBasic.background=true;
            _txtGrid.backgroundColor=_txtBasic.backgroundColor=0xffff99;
            _txtBasic.height=_txtGrid.height=20;
            _txtBasic.width=_txtGrid.width=135;
            _txtBasic.alpha=_txtGrid.alpha=0.9;
            _txtBasic.x=stage.stageWidth-_txtBasic.width;
            _slider.maximum=300;
            _slider.minimum=30;
            _slider.snapInterval=10;
            _slider.y=10;
            _slider.value=_numBalls;
            _slider.width=200;
            _slider.x=stage.stageWidth/2-_slider.width/2;
 
            makeBalls();//创建一堆小球
 
            var startTime:int;
            var elapsed:int;
 
            startTime=getTimer();
            for (i=0; i<10; i++) {
                makeGrid();
                assignBallsToGrid();
                checkGrid();
            }
            elapsed=getTimer()-startTime;
            trace("网格检测：",elapsed);
            _txtGrid.text=_numBalls+"个球网络检测："+elapsed.toString();
 
            startTime=getTimer();
            for (i=0; i<10; i++) {
                basicCheck();
            }
            elapsed=getTimer()-startTime;
            trace("两两检测：",elapsed);
            _txtBasic.text=_numBalls+"个球两两检测："+elapsed.toString();
 
            if (isClear) {
                addChild(_txtBasic);
                addChild(_txtGrid);
                addChild(_slider);
            }
        }
 
        private function sliderGrag(e:SliderEvent):void {
            _numBalls=e.value;
            trace("sliderGrag");
        }
 
        private function stageClick(e:MouseEvent):void {
            trace("stageClick");
            test(true);
        }
 
        //创建_numBalls个小球实例，并随机摆放到舞台上
        private function makeBalls():void {
            _balls=new Array  ;
            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;
                addChild(ball);
                ball.alpha=0.5;
                _balls.push(ball);
            }
        }
 
        private function makeGrid():void {
            _grid=new Array  ;
            for (var i:int=0; i<stage.stageWidth/GRID_SIZE; i++) {//计算网格列数
                _grid[i]=new Array  ;
                for (var j:int=0; j<stage.stageHeight/GRID_SIZE; j++) {//计算网格行数
                    _grid[i][j]=new Array  ;//每个单元格对应一个数组（用来存放该单元格中的小球）
                }
            }
        }
 
        private function drawGrid():void {
            // 画出行列线
            graphics.lineStyle(0,0x999999);
            for (var i:int=0; i<=stage.stageWidth; i+=GRID_SIZE) {
                graphics.moveTo(i,0);
                graphics.lineTo(i,stage.stageHeight);
            }
            for (i=0; i<=stage.stageHeight; i+=GRID_SIZE) {
                graphics.moveTo(0,i);
                graphics.lineTo(stage.stageWidth,i);
            }
        }
 
 
        private function assignBallsToGrid():void {
            for (var i:int=0; i<_numBalls; i++) {
                // 球的位置除以格子大小，得到该球所在网格的行列数
                var ball:Ball=_balls[i] as Ball;
                var xpos:int=Math.floor(ball.x/GRID_SIZE);
                var ypos:int=Math.floor(ball.y/GRID_SIZE);
                _grid[xpos][ypos].push(ball);//将小球推入对应单元格数组
            }
        }
 
        private function checkGrid():void {
            for (var i:int=0; i<_grid.length; i++) {
                for (var j:int=0; j<_grid[i].length; j++) {
                    checkOneCell(i,j);//单元格cell_self自身的碰撞检测
                    checkTwoCells(i,j,i+1,j);//单元格cell_self与单元格cell_right(右侧)的碰撞检测
                    checkTwoCells(i,j,i-1,j+1);//单元格cell_self与单元格cell_left_bottom(左下角)的碰撞检测
                    checkTwoCells(i,j,i,j+1);//单元格cell_self与单元格cell_bottom(下侧)的碰撞检测
                    checkTwoCells(i,j,i+1,j+1);//单元格cell_self与单元格cell_right_bottom(右下角)的碰撞检测
                }
            }
        }
 
        //cellSelf与自身的检测
        private function checkOneCell(x:int,y:int):void {
            // 检测当前格子内所有的对象
            var cell:Array=_grid[x][y] as Array;
            for (var i:int=0; i<cell.length-1; i++) {
                var ballA:Ball=cell[i] as Ball;
                for (var j:int=i+1; j<cell.length; j++) {
                    var ballB:Ball=cell[j] as Ball;
                    checkCollision(ballA,ballB);
                }
            }
        }
 
        //cellSelf与其它单元格的检测
        private function checkTwoCells(x1:int,y1:int,x2:int,y2:int):void {
            //确保要检测的格子存在
            if (x2<0) {
                return;
            }
            if (x2>=_grid.length) {
                return;
            }
            if (y2>=_grid[x2].length) {
                return;
            }
            var cell0:Array=_grid[x1][y1] as Array;
            var cell1:Array=_grid[x2][y2] as Array;
 
            // 检测当前格子和邻接格子内所有的对象
            for (var i:int=0; i<cell0.length; i++) {
                var ballA:Ball=cell0[i] as Ball;
                for (var j:int=0; j<cell1.length; j++) {
                    var ballB:Ball=cell1[j] as Ball;
                    checkCollision(ballA,ballB);
                }
            }
        }
 
        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;
            }
        }
 
        //(最原始的)两两检测
        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);
                }
            }
        }
    }
}