用AS3实现连连看Demo版

package
{
    import flash.display.*;
    import flash.events.MouseEvent;
    import flash.events.Event;
    import flash.utils.getDefinitionByName;
    import flash.text.*;
    import flash.utils.Timer;
    import flash.events.TimerEvent;

    public class seeLink extends Sprite
    {
        private var mapArray:Array;
        private var widthSize:Number = 12;
        private var heightSize:Number = 12;
        private var imageArray, imageArray2:Array;
        private var oneCornerArray, twoCornerArray:Array;
        private var allArray:Array;
        private var recFrame:RecFrame;
        private var preUnit, nextUnit:mapUnit;
        private var timeBar:TimeBar;
        private var clickCount:Number = 0;
        private var flag:Boolean = false;
        private var flag_mc:MovieClip;

        public function seeLink()
        {
            mapArray = new Array();
            allArray = new Array();
            oneCornerArray = new Array();
            twoCornerArray = new Array();
            setImageArray();
            attachText();
            attachTimeBar();
            attachMap();
            attachFlag("start");
        }

        private function attachText():void
        {
            var timeTextField:TextField = new TextField();
            timeTextField.x = 7;
            timeTextField.y = 15;
            timeTextField.text = "时间";
            this.addChild(timeTextField);
        }

        public function attachTimeBar():void
        {
            timeBar = new TimeBar();
            timeBar.x = 40;
            timeBar.y = 20;
            this.addEventListener(Event.ENTER_FRAME, myOnEnterFrame);
            this.addChild(timeBar);
        }

        private function myOnEnterFrame(e:Event):void
        {
            timeSub();
        }

        private function attachFlag(type:String):void
        {
            flag_mc = new Flag();
            //trace(type); 
            if (type == "win")
            {
                flag_mc.gotoAndStop(1);
            }
            else if (type == "lose")
            {
                flag_mc.gotoAndStop(2);
            }
            else if (type == "start")
            {
                flag_mc.gotoAndStop(3);
            }
            flag_mc.x = stage.stageWidth / 2 - flag_mc.width / 2;
            flag_mc.y = stage.stageHeight / 2 - flag_mc.height / 2;
            this.addChild(flag_mc);
            var myTimer:Timer = new Timer(3000, 1);
            myTimer.addEventListener("timer", timerHandler);
            myTimer.start();
        }

        private function timerHandler(event:TimerEvent):void
        {
            trace("removeFlag");
            this.removeChild(flag_mc);
        }

        private function checkIsWin():Boolean
        {
            for (var i:Number = 0; i < mapArray.length; i++)
            {
                if (mapArray[i]._typeNum != -1)
                {
                    return false;
                }
            }
            return true;
        }

        private function removeEnterFrame():void
        {
            this.removeEventListener(Event.ENTER_FRAME, myOnEnterFrame);
        }

        private function timeSub():void
        {
            //trace("timeBar._width="+timeBar._width); 
            timeBar.width -= 0.08;
            if (timeBar.width < 0.5)
            {
                //trace("remove"); 
                timeBar.width = 0;
                attachFlag("lose");
                removeEnterFrame();
            }
            else
            {
                var isWin:Boolean = checkIsWin();
                if (isWin)
                {
                    attachFlag("win");
                    removeEnterFrame();
                }
            }

        }

        public function setLatterArray(_Arr:Array):Array
        {
            var len:Number = _Arr.length;
            var j:Number;
            for (j = 0; j < len; j++)
            {
                var rand:Number = Math.floor(Math.random() * len);
                var temp:Number = _Arr[j];
                _Arr[j] = _Arr[rand];
                _Arr[rand] = temp;
            }
            return _Arr;
        }

        private function setImageArray()
        {
            var beforeArray = new Array();
            for (var i:Number = 0; i < (widthSize * heightSize - 4 * (heightSize - 1)) / 2; i++)
            {
                var randomNum = Math.floor(Math.random() * 28);
                beforeArray.push(randomNum);
            }
            //trace("before beforeArray="+beforeArray); 
            var tempArray:Array = beforeArray.slice(0);
            //trace("before tempArray="+tempArray); 
            var laterArray:Array = setLatterArray(tempArray);
            //trace("later laterArray="+laterArray); 
            //trace("imageArray2="+imageArray2); 
            allArray = beforeArray.concat(laterArray);
            //trace("allArray="+allArray); 
        }

        private function attachMap()
        {
            var arrayNum:Number = 0;
            for (var i:Number = 0; i < heightSize; i++)
            {
                for (var j:Number = 0; j < widthSize; j++)
                {
                    //加载底 
                    var edge:Edge = new Edge();
                    edge.x = 20 + j * edge.width;
                    edge.y = 80 + i * edge.height;
                    //edge.name = i*10+j; 
                    this.addChild(edge);
                    var _num = i * heightSize + j;
                    //加上周围透明mc,用来显示路径 
                    if (i == 0 || i == heightSize - 1 || j == 0 || j == widthSize - 1)
                    {
                        var cls = getDefinitionByName("cover");
                        var temp = new cls();
                        edge.addChild(temp)
                        mapArray[_num] = new mapUnit(this, edge, i, j, -1);
                    }
                    else
                    {
                        //底上加载各种图片 
                        var typeNum = allArray[arrayNum];
                        arrayNum++;
                        var image_cls = getDefinitionByName("type" + typeNum);
                        var image = new image_cls();
                        image.name = typeNum;
                        edge.addChild(image)
                        mapArray[_num] = new mapUnit(this, edge, i, j, typeNum);
                    }
                }
            }
        }

        private function removeRecFrame()
        {
            /*trace("recFrame="+recFrame);
               if(recFrame!=null){
               this.removeChild(recFrame);
             }*/
            recFrame.visible = false;
        }

        private function attachRecFrame(unit:mapUnit)
        {
            //removeRecFrame(); 
            if (recFrame == null)
            {
                recFrame = new RecFrame();
                this.addChild(recFrame);
            }
            recFrame.visible = true;
            recFrame.x = unit.graphic.x;
            recFrame.y = unit.graphic.y;

        }

        private function addClickCount():void
        {
            clickCount++;
        }

        public function addRecFrame(unit:mapUnit)
        {
            addClickCount();
            attachRecFrame(unit);
            //trace("clickCount="+clickCount); 
            if (clickCount == 1)
            {
                preUnit = unit;
            }
            else
            {
                if (preUnit == unit)
                {
                    //trace("flag="+flag); 
                    flag = !flag;
                    //trace("== flag="+flag); 
                    if (flag)
                    {
                        removeRecFrame();
                    }
                    else
                    {
                        attachRecFrame(unit);
                    }
                }
                else
                {
                    //trace("preUnit._typeNum="+preUnit._typeNum); 
                    //trace("unit._typeNum="+unit._typeNum); 
                    if (preUnit._typeNum == unit._typeNum)
                    {
                        checkIsLink(preUnit, unit)
                    }
                    preUnit = unit;
                    flag = false;
                }
            }
        }

        private function checkIsLink(preUnit, nextUnit:mapUnit)
        {
            var isBeeLink:Number = isBeeLineLink(preUnit, nextUnit);
            trace("isBeeLink=" + isBeeLink);
            //isBeeLink return parameter: 
            //0.没有符合条件； 
            //1.符合条件,联结成功； 
            //2.符合条件,没有联结成功. 
            //一级检测成功 
            if (isBeeLink == 1)
            {
                removeHandle(preUnit, nextUnit);
            }
            //一级检测不成功 
            if (isBeeLink == 2 || isBeeLink == 0)
            {
                //离开一级检验,进入二级检测. 
                secondCheck(preUnit, nextUnit);
            }
        }

        private function secondCheck(preUnit, nextUnit:mapUnit):void
        {
            var _isOneCornerLink:Boolean = isOneCornerLink(preUnit, nextUnit);
            trace("_isOneCornerLink=" + _isOneCornerLink);
            //二级检测成功 
            if (_isOneCornerLink)
            {
                removeHandle(preUnit, nextUnit);
            }
            else
            {
                //二级检测不成功,离开二级检验,进入三级检验. 
                thirdCheck(preUnit, nextUnit);
            }
        }

        private function thirdCheck(preUnit, nextUnit:mapUnit):void
        {
            var _isTwoCornerLink:Boolean = isTwoCornerLink(preUnit, nextUnit);
            trace("_isTwoCornerLink=" + _isTwoCornerLink);
            if (_isTwoCornerLink)
            {
                removeHandle(preUnit, nextUnit);
            }
            removeArray();
        }

        private function isTwoCornerLink(preUnit, nextUnit:mapUnit):Boolean
        {
            //trace("preUnit.xNo="+preUnit.xNo); 
            //trace("preUnit.yNo="+preUnit.yNo); 
            //trace("nextUnit.xNo="+nextUnit.xNo); 
            //trace("nextUnit.yNo="+nextUnit.yNo); 
            //trace("in isTwoCornerLink"); 
            pushToOneCornerArray(preUnit);
            pushToTwoCornerArray(nextUnit);
            //trace("oneCornerArray.length="+oneCornerArray.length); 
            //trace("twoCornerArray.length="+twoCornerArray.length); 
            var tempArray:Array = new Array();
            for (var i:Number = 0; i < oneCornerArray.length; i++)
            {
                for (var j:Number = 0; j < twoCornerArray.length; j++)
                {
                    var temp1:mapUnit = oneCornerArray[i];
                    var temp2:mapUnit = twoCornerArray[j];
                    //trace("temp1.xNo="+temp1.xNo); 
                    //trace("temp1.yNo="+temp1.yNo); 
                    //trace("temp2.xNo="+temp2.xNo); 
                    //trace("temp2.yNo="+temp2.yNo); 
                    if (temp1.xNo == temp2.xNo)
                    {
                        if (temp1.yNo == preUnit.yNo && temp2.yNo == nextUnit.yNo)
                        {
                            tempArray.push({one: temp1, two: temp2});
                        }
                    }
                    if (temp1.yNo == temp2.yNo)
                    {
                        if (temp1.xNo == preUnit.xNo && temp2.xNo == nextUnit.xNo)
                        {
                            tempArray.push({one: temp1, two: temp2});
                        }
                    }
                }
            }
            //trace("tempArray.length="+tempArray.length); 
            for (var m:Number = 0; m < tempArray.length; m++)
            {
                var oneCorner:mapUnit = tempArray[m].one;
                var twoCorner:mapUnit = tempArray[m].two;
                //trace("oneCorner.xNo="+oneCorner.xNo); 
                //trace("oneCorner.yNo="+oneCorner.yNo); 
                //trace("twoCorner.xNo="+twoCorner.xNo); 
                //trace("twoCorner.yNo="+twoCorner.yNo); 
                if (oneCorner.yNo == twoCorner.yNo)
                {
                    var result1:Number = compare(oneCorner.yNo, oneCorner.xNo, twoCorner.xNo, "x");
                }
                if (oneCorner.xNo == twoCorner.xNo)
                {
                    var result2:Number = compare(oneCorner.xNo, oneCorner.yNo, twoCorner.yNo, "y");
                }
                if (result1 == 1 || result2 == 1)
                {
                    return true;
                }
            }
            return false;
        }

        private function removeHandle(preUnit, nextUnit:mapUnit):void
        {
            removeUnit(preUnit);
            removeUnit(nextUnit);
            removeRecFrame();
        }

        private function removeArray():void
        {
            //trace("oneCornerArray.length="+oneCornerArray.length); 
            //trace("twoCornerArray.length="+twoCornerArray.length); 
            oneCornerArray.splice(0);
            twoCornerArray.splice(0);
        }

        private function checkOneCornerLink(cornerUnit, preUnit, nextUnit:mapUnit):Boolean
        {
            //如果拐角为空 
            //trace("cornerUnit._typeNum="+cornerUnit._typeNum); 
            //trace("cornerUnit.xNo="+cornerUnit.xNo); 
            //trace("cornerUnit.yNo="+cornerUnit.yNo); 
            if (cornerUnit._typeNum == -1)
            {
                //如果拐角满足条件可以联结，则返回成功，否则，判断另一个拐角 
                var result1, result2:Number;
                if (cornerUnit.xNo == preUnit.xNo)
                {
                    result1 = compare(cornerUnit.xNo, cornerUnit.yNo, preUnit.yNo, "y");
                }
                if (cornerUnit.yNo == preUnit.yNo)
                {
                    result1 = compare(cornerUnit.yNo, cornerUnit.xNo, preUnit.xNo, "x");
                }
                if (cornerUnit.xNo == nextUnit.xNo)
                {
                    result2 = compare(cornerUnit.xNo, cornerUnit.yNo, nextUnit.yNo, "y");
                }
                if (cornerUnit.yNo == nextUnit.yNo)
                {
                    result2 = compare(cornerUnit.yNo, cornerUnit.xNo, nextUnit.xNo, "x");
                }
                //result,result,result,result,result,result,result,result,result,result; 
                //trace("result1="+result1); 
                //trace("result2="+result2); 
                if (result1 == 1 && result2 == 1)
                {
                    return true;
                }
                else
                {
                    //如果中间有中断，返回不成功 
                    return false;
                }
            }
            else
            {
                //如果拐角不为空，则直接返回不成功 
                return false;
            }
        }

        private function isOneCornerLink(preUnit, nextUnit:mapUnit):Boolean
        {
            //trace("preUnit.xNo="+preUnit.xNo); 
            //trace("preUnit.yNo="+preUnit.yNo); 
            //trace("nextUnit.xNo="+nextUnit.xNo); 
            //trace("nextUnit.yNo="+nextUnit.yNo); 
            //找到拐点 
            var oneCornerUnit:mapUnit = getUnit(preUnit.xNo, nextUnit.yNo);
            var oneTest:Boolean = checkOneCornerLink(oneCornerUnit, preUnit, nextUnit);
            //trace("oneTest="+oneTest); 
            //如果此拐点连接不成功 
            if (!oneTest)
            {
                //找到另一个拐点 
                var oneCornerUnit2:mapUnit = getUnit(nextUnit.xNo, preUnit.yNo);
                //trace("oneCornerUnit2._typeNum="+oneCornerUnit2._typeNum); 
                return checkOneCornerLink(oneCornerUnit2, preUnit, nextUnit);
            }
            else
            {
                return oneTest;
            }
        }

        private function removeUnit(unit:mapUnit)
        {
            //trace("unit._typeNum="+unit._typeNum); 
            //trace(unit.graphic.getChildByName(unit._typeNum)); 
            unit.graphic.removeChild(unit.graphic.getChildByName(unit._typeNum));
            //delete unit.graphic.onPress; 
            unit.removeMouseEvent();
            unit.setTypeNum(-1);
        }

        //判断两点之间图片是否全为空，1表示为空，可以连接，2表示不为空，中断连接 
        private function compare(variable, preNo, nextNo:Number, type:String):Number
        {
            //trace("in compare type="+type); 
            if (preNo < nextNo)
            {
                min = preNo;
                max = nextNo;
            }
            else
            {
                min = nextNo;
                max = preNo;
            }
            //trace("min="+min); 
            //trace("max="+max); 
            if (max - min == 1)
            {
                return 1;
            }
            else
            {
                var tempUnit:mapUnit;
                for (var i:Number = min + 1; i < max; i++)
                {
                    if (type == "x")
                    {
                        tempUnit = getUnit(i, variable);
                    }
                    else if (type == "y")
                    {
                        tempUnit = getUnit(variable, i);
                    }
                    //trace("tempUnit._typeNum="+tempUnit._typeNum); 
                    //trace("tempUnit._xNo="+tempUnit.xNo); 
                    //trace("tempUnit._yNo="+tempUnit.yNo); 
                    if (tempUnit._typeNum != -1)
                    {
                        return 2;
                    }
                }
                return 1;

            }
        }

        private function isBeeLineLink(preUnit, nextUnit:mapUnit):Number
        {
            if (preUnit.xNo == nextUnit.xNo)
            {
                return compare(preUnit.xNo, preUnit.yNo, nextUnit.yNo, "y");
            }
            if (preUnit.yNo == nextUnit.yNo)
            {
                return compare(preUnit.yNo, preUnit.xNo, nextUnit.xNo, "x");
            }
            if (preUnit.yNo != nextUnit.yNo && preUnit.xNo != nextUnit.xNo)
            {
                return 0;
            }
        }

        private function getUnit(xNo, yNo:Number):mapUnit
        {
            //trace("getUnit xNo="+xNo); 
            //trace("getUnit yNo="+yNo); 
            var num:Number = yNo * heightSize + xNo;
            return mapArray[num];
        }

        private function pushToOneCornerArray(preUnit:mapUnit):void
        {
            //trace("left***************************"); 
            for (var i:Number = preUnit.xNo - 1; i > -1; i--)
            {
                var unitLeft:mapUnit = getUnit(i, preUnit.yNo);
                //图片不为空 
                //trace("unitLeft._typeNum="+unitLeft._typeNum); 
                if (unitLeft._typeNum != -1)
                {
                    break;
                }
                else
                {
                    //图片为空，则把这个位置的unit放入数组作为corner考虑 
                    oneCornerArray.push(unitLeft);
                }
            }
            //trace("right***************************"); 
            //trace("oneCornerArray.length="+oneCornerArray.length); 
            for (var j:Number = preUnit.xNo + 1; j < widthSize; j++)
            {
                var unitRight:mapUnit = getUnit(j, preUnit.yNo);
                //trace("unitRight._typeNum="+unitRight._typeNum); 
                //trace("unitRight.xNo="+unitRight.xNo); 
                //trace("unitRight.yNo="+unitRight.yNo); 
                //图片不为空 
                if (unitRight._typeNum != -1)
                {
                    break;
                }
                else
                {
                    //图片为空，则把这个位置的unit放入数组作为corner考虑 
                    oneCornerArray.push(unitRight);
                }
            }
            //trace("up***************************"); 
            //trace("oneCornerArray.length="+oneCornerArray.length); 
            for (var m:Number = preUnit.yNo - 1; m > -1; m--)
            {
                var unitUp:mapUnit = getUnit(preUnit.xNo, m);
                //trace("unitUp._typeNum="+unitUp._typeNum); 
                //图片不为空 
                if (unitUp._typeNum != -1)
                {
                    break;
                }
                else
                {
                    //图片为空，则把这个位置的unit放入数组作为corner考虑 
                    oneCornerArray.push(unitUp);
                }
            }
            //trace("down***************************"); 
            //trace("oneCornerArray.length="+oneCornerArray.length); 
            for (var n:Number = preUnit.yNo + 1; n < heightSize; n++)
            {
                var unitDown:mapUnit = getUnit(preUnit.xNo, n);
//trace("unitDown._typeNum="+unitDown._typeNum); 
                //图片不为空 
                if (unitDown._typeNum != -1)
                {
                    break;
                }
                else
                {
                    //图片为空，则把这个位置的unit放入数组作为corner考虑 
                    oneCornerArray.push(unitDown);
                }
            }
            //trace("oneCornerArray.length="+oneCornerArray.length); 
        }

        private function pushToTwoCornerArray(nextUnit:mapUnit):void
        {
            //trace("Two corner left***************************"); 
            for (var i:Number = nextUnit.xNo - 1; i > -1; i--)
            {
                var unitLeft = getUnit(i, nextUnit.yNo);
                //图片不为空 
                if (unitLeft._typeNum != -1)
                {
                    break;
                }
                else
                {
                    //图片为空，则把这个位置的unit放入数组作为corner考虑 
                    twoCornerArray.push(unitLeft);
                }
            }
            //trace("Two corner right***************************"); 
            for (var j:Number = nextUnit.xNo + 1; j < widthSize; j++)
            {
                var unitRight = getUnit(j, nextUnit.yNo);
                //trace("unitRight._typeNum="+unitRight._typeNum); 
                //trace("unitRight.xNo="+unitRight.xNo); 
                //trace("unitRight.yNo="+unitRight.yNo); 
                //图片不为空 
                if (unitRight._typeNum != -1)
                {
                    break;
                }
                else
                {
                    //图片为空，则把这个位置的unit放入数组作为corner考虑 
                    twoCornerArray.push(unitRight);
                }
            }
            //trace("Two corner up***************************"); 
            for (var m:Number = nextUnit.yNo - 1; m > -1; m--)
            {
                var unitUp = getUnit(nextUnit.xNo, m);
                //图片不为空 
                if (unitUp._typeNum != -1)
                {
                    break;
                }
                else
                {
                    //图片为空，则把这个位置的unit放入数组作为corner考虑 
                    twoCornerArray.push(unitUp);
                }
            }
            //trace("Two corner down***************************"); 
            for (var n:Number = nextUnit.yNo + 1; n < heightSize; n++)
            {
                var unitDown = getUnit(nextUnit.xNo, n);
                //图片不为空 
                if (unitDown._typeNum != -1)
                {
                    break;
                }
                else
                {
                    //图片为空，则把这个位置的unit放入数组作为corner考虑 
                    twoCornerArray.push(unitDown);
                }
            }
        }

    }

}