package net.conanlwl
{
    import flash.display.Sprite;
   
    public class Piece extends Sprite
    {
        private var m_row:uint;
        private var m_col:uint;
       
        public var Up:Object;
        public var Right:Object;
        public var Buttom:Object;
        public var Left:Object;
       
        private var m_virtualX:Number;
        private var m_virtualY:Number;       
       
        public function Piece(_row:uint,_col:uint,_virtualX:Number,_virtualY:Number)
        {
            this.m_row = _row;
            this.m_col = _col;
            m_virtualX = _virtualX;
            m_virtualY = _virtualY;
        }
       
        public function get virtualX():Number{
            return m_virtualX;
        }
       
        public function get virtualY():Number{
            return m_virtualY;
        }
       
        public function get Row():uint{
            return m_row;
        }
        public function get Col():uint{
            return m_col;
        }
    }
}

其中的virtualX,virtualY,Row,Col都是只读的,也即是说,在声明之后,这四个值就是固定的了.

我们给一张拼好的图的每个小碎片做一个编号.如图1: 

var inaccuracy:Number = 8; //吸附的误差值
if(Math.abs((L.x - M.x) - (L.virtualX - M.virtualX)) <=inaccuracy ){//当前X坐标的差值,与他们的虚坐标的差值接近时
     if(Math.abs((L.y - M.y) - (L.virtualY - M.virtualY)) <=inaccuracy){    
           //吸附条件成立
     }
}

当我们用鼠标拿着L与M碰撞并吸附条件成立时,就将L从舞台转移到M里面去,也即M.addChild(L),并修正L的坐标与M能够准确拼合.至此L与M成为一个整体M,如图3

if(Math.abs((H.x - W.x) - (H.virtualX - W.virtualX)) <=inaccuracy ){//当前X坐标的差值,与他们的虚坐标的差值接近时
    if(Math.abs((H.y - W.y) - (H.virtualY - W.virtualY)) <=inaccuracy){   
                    //吸附条件成立
     }
}

如果是拿H碰W,则将H里的三个小碎片一片一片地搬到W里面去,反之,则W搬H.如果此时仍用Row与Col的差值来判断,就会发现吸附条件不成立了.因为H的Row与Col为1,2,而W的则为4,2,所以虽然他们处于同列,但行数却差了4-1=3.所以行列差值比较法就不成立了.

为什么要将大H的三个小碎片一片一片地搬到大W里面,而不直接将大H搬到大W里面去就行了呢?这是为了保证舞台中碎片的层次关系只有二层而为避免对角吸附也会成立的情况做准备(如图7).也即大碎片里面就是小碎片了,小碎片里不会再有小碎片.

//检查p1与p2里是否相邻连接,避免出现对角连接
private function testHit(p1:Piece,p2:Piece):Boolean{
    if(Math.abs(p1.Row - p2.Row) + Math.abs(p1.Col - p2.Col) == 1) return true;
    var p:Piece;
    var i:uint = 0;
    var j:uint = 0;
    for(i=0;i<p2.numChildren;i++){ //p1自身与p2的child碰撞
        p = p2.getChildAt(i) as Piece;
        if(Math.abs(p1.Row - p.Row) + Math.abs(p1.Col - p.Col) == 1) return true;
    }
    for(i=0;i<p1.numChildren;i++){ //p2自身与p1的child碰撞
        p = p1.getChildAt(i) as Piece;
        if(Math.abs(p2.Row - p.Row) + Math.abs(p2.Col - p.Col) == 1) return true;
    }
    for(i=0;i<p1.numChildren;i++){//p1的child与p2的child碰撞
        for(j=0;j<p2.numChildren;j++){
         p = p1.getChildAt(i) as Piece;
         var pp:Piece = p2.getChildAt(j) as Piece;
         if(Math.abs(pp.Row - p.Row) + Math.abs(pp.Col - p.Col) == 1) return true;
        }
    }        
         return false; 
}

所以绕了这么大的一个圈,就是为了避免出现这样的一个问题,所以如果你的游戏是允许对角拼接的话,那么你大可不用这么麻烦,仍然按照上面的吸附判断公式,然后直接A.addChild(B)或者B.addChild(A)就行了..无论是大A碎片或者是小A碎片,总之将一个大碎片直接搬到另一块碎片里面去就行了.

至此我们整个吸附判断的过程就完成了.所以当我们扩展到多角度的吸附判断时,只是上面的公式中,x与y,virtualX与virtualY之间的相对关系反生了一些变化而已.下面就是扩展多角度吸附判断的公式,

public function getArcDot(pos:String):Object{
            var rnd:Number = Math.random()<0.5 ? 0:1;//0为凸,1为凹           
            var dist:Number = Math.sqrt(2 * m_pieceArcRadiu * m_pieceArcRadiu);//圆弧两个商战的距离
           
            var obj:Object = new Object();           
           
            switch(pos){
                case "right"://画右边
                    var _arcY:Number = m_pieceH / 2;
                    var _arcX:Number = this.m_pieceArcRadiu * Math.random() * Math.pow(-1,rnd) + m_pieceW;
                    var _angle:Number = 225 - rnd * 180;//开始角度               
                   
                    //画圆弧的起笔位置,顺时针画,凸时,起点在下,凹时起点在上.
                    var nStartX:Number = _arcX + Math.cos(_angle* Math.PI / 180) * m_pieceArcRadiu;
                          var nStartY:Number = _arcY + Math.sin(_angle* Math.PI / 180) * m_pieceArcRadiu;                            
                     
                          obj.o = new Point(_arcX,_arcY);
                          obj.angle = _angle;
                          if(rnd == 0){
                              obj.p1 = new Point(nStartX,nStartY);
                              obj.p2 = new Point(nStartX,nStartY + dist);
                              obj.clockwise = true;
                          }
                          else
                          {
                              obj.p2 = new Point(nStartX,nStartY);
                              obj.p1 = new Point(nStartX,nStartY - dist);
                              obj.clockwise = false;
                          }                                      
                    break;
                    case "down":
                        var _arcX:Number = m_pieceW / 2;
                        var _arcY:Number = m_pieceArcRadiu * Math.random() * Math.pow(-1,rnd) + m_pieceH;
                        var _angle:Number = 315 - rnd * 180; //开始角度
                       
                        //画圆弧的起笔位置,顺时针画,凸时,起点在下,凹时起点在上.
                        var nStartX:Number = _arcX + Math.cos(_angle* Math.PI / 180) * m_pieceArcRadiu;
                          var nStartY:Number = _arcY + Math.sin(_angle* Math.PI / 180) * m_pieceArcRadiu;                    
                         
                          obj.o = new Point(_arcX,_arcY);
                          obj.angle = _angle;
                          if(rnd == 0){
                              obj.p1 = new Point(nStartX,nStartY);
                              obj.p2 = new Point(nStartX - dist,nStartY);
                              obj.clockwise = true;
                          }
                          else
                          {
                              obj.p2 = new Point(nStartX,nStartY);
                              obj.p1 = new Point(nStartX + dist,nStartY);
                              obj.clockwise = false;
                          }                     
                    break;
                }           
            return obj;
        }

其中的object的结构为:

o 圆心坐标
angle 圆弧的开始角度
p1 圆弧的第一个端点
p2 圆弧的第二个端点
clockwise 画圆弧时是顺时针画还是逆时针画

接着我们来创建一个碎片类Piece: