智慧 + 毅力 = 无所不能

正确性、健壮性、可靠性、效率、易用性、可读性、可复用性、兼容性、可移植性...

导航

用AS3实现连连看Demo版

Posted on 2009-11-20 18:01  Bill Yuan  阅读(1243)  评论(0编辑  收藏  举报
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(30001);
            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);
                }
            }
        }

    }

}