as3连连看游戏算法

关注

转载最新推荐文章于 2025-08-17 13:58:23 发布 3.7k 阅读 AI 写同款· GEO 优化 ›

算法基础之python实现递归法中简易连连看小游戏问题：简单版连连看小游戏一个分割成w*h个正方格子的矩形板上，每个正方格子可以有游戏卡，也可以没有游戏卡两个游戏卡之间有一条路径相连需满足以下三个条件：1.路径只包含水平和垂直的直线段2.路径不能穿过别的游戏卡片3.允许路径临时离开矩形板输入要求：第一行包括两个整数：w 和 h ; w:矩形板的宽度，h:矩形板的长度下面h行，每行包括w个字符，表示矩形板上卡片的分布情况：'X'代表这个地方有卡片；... 阅读详情

这几天一直在忙的一个东西,因为时间的关系,只弄了主要的算法,计时,分数,划线,点击效果等内容都没有管=.=
先来看连连看的规则分析，这里将选中的2个Obj分3种情况来讨论，一是同位于X轴，二是同位于Y轴，三是不同X，Y轴。
而第三种情况其实又可以归结到第1和第2种情况，具体的操作是先判断是否同X,Y轴,是的话先检测能否直连,不能的话判断不直连的情况.
如果两者属于不同的X,Y轴,那么先判断通过一点连接,然后再判断通过两点连接的情况,这里图方便用了最烂的方法.

下边是针对示意图的分析:
连连看
对应图示的分析,假定objA和objB是不同的X,Y轴位置，那么可以从objA开始整列开始处到结束循环寻找到一点tmpA，如果objA和tmpA可以直连(testCrossAbleX()方法)，那么判断tmpA和objB的拐点位置tmpB和tmpA的连通性(testCrossAbleY()方法)，之后再判断tmpB和objB的连通性(testCrossAbleX()方法)和tmpB和objB是不是同一点。
其实最有效率的做法是从objA和objB两个中间的点开始检索，有兴趣的自己改吧…
Demo的代码如下：

 
        stage.align = StageAlign.TOP_LEFT;
       
        stage.scaleMode = StageScaleMode.NO_SCALE;
       
        var 
         PICWIDTHNUM:uint = 13;
       
        var 
         PICHEIGHTNUM:uint = 10;
       
        var 
         PICSIZE:uint = 40;
       
        var 
         aryPic:Array = [1,2,3,4,5,6,7,8];
       
        var 
         aryPicType:Array = [];
       
        var 
         aryPath:Array = [];
       
        var 
         aryCrossPath:Array = [];
       
        var 
         WIDTHNUM:uint = PICWIDTHNUM + 2;
       
        var 
         HEIGHTNUM:uint = PICHEIGHTNUM + 2;
       
        var 
         PATHSIZE:uint = 40;
       
        var 
         clkFlag:Boolean = 
        false
        ;
       
        var 
         firstObj:Pic;
       
        var 
         secondObj:Pic;
       
        //生成路径图
       
        setPath ();
       
        function 
         setPath () {
       
        for 
         (
        var 
         i:uint=0; i < WIDTHNUM; i++) {
       
        aryPath[i] = [];
       
        for 
         (
        var 
         j:uint=0; j < HEIGHTNUM; j++) {
       
        var 
         path = 
        new 
         Path();
       
        path.x = PATHSIZE * i;
       
        path.y = PATHSIZE * j;
       
        path.disX = i;
       
        path.disY = j;
       
        path.name = 
        "path" 
         + path.disX * 8 + path.disY;
       
        path.txt_disInfo.text = 
        "(" 
         + path.disX + 
        "," 
         + path.disY + 
        ")"
        ;
       
        if 
         (i ==0 || i == (WIDTHNUM - 1) || j == 0 || j ==(HEIGHTNUM - 1)) {
       
        setCrossFlag (i,j,path,
        true
        );
       
        } 
        else 
         {
       
        setCrossFlag (i,j,path,
        false
        );
       
        }
       
        //trace(path.disX);
       
        //trace(path.disY);
       
        addChild (path);
       
        }
       
        }
       
        //trace (aryPath);
       
        }
       
        //设置路径的可通过和不可通过crossFlag
       
        function 
         setCrossFlag (i:uint,j:uint,path:Path,flag:Boolean) {
       
        aryPath[i][j] = flag;
       
        path.crossFlag = flag;
       
        path.txt_CrossFlag.text = String(flag);
       
        }
       
        //生成图片数组并随机打乱
       
        setTypeArray ();
       
        function 
         setTypeArray () {
       
        var 
         i:uint = 0;
       
        while 
         (i < PICWIDTHNUM * PICHEIGHTNUM / 2) {
       
        //picArray是图片数组
       
        aryPicType.push (i % (aryPic.length) +1);
       
        aryPicType.push (i % (aryPic.length) +1);
       
        ++i;
       
        }
       
        aryPicType = aryRandom(aryPicType);
       
        }
       
        //数组随机排列函数
       
        function 
         aryRandom (ary:Array):Array {
       
        var 
         ary_temp:Array = 
        new 
         Array();
       
        for 
         (
        var 
         i:int = ary.length; i > 0; i--) {
       
        var 
         int_num:Number = int(Math.random() * ary.length);
       
        ary_temp.push (ary[int_num]);
       
        ary.splice (int_num, 1);
       
        }
       
        return 
         ary_temp;
       
        }
       
        //图片设置部分
       
        initPic ();
       
        var 
         startNum:uint = 0;
       
        function 
         initPic () {
       
        for 
         (
        var 
         i:uint=0; i < PICWIDTHNUM; i++) {
       
        for 
         (
        var 
         j:uint=0; j < PICHEIGHTNUM; j++) {
       
        setPic (i, j, aryPicType[startNum]);
       
        startNum++;
       
        }
       
        }
       
        }
       
        //设置图片类型，位置，以及点击事件
       
        function 
         setPic (i:uint, j:uint, type:uint) {
       
        var 
         pic = 
        new 
         Pic();
       
        pic.x = PATHSIZE + PICSIZE * i;
       
        pic.y = PATHSIZE + PICSIZE * j;
       
        pic.disX = i + 1;
       
        pic.disY = j + 1;
       
        pic.pType = type;
       
        pic.name = 
        "pic" 
         + pic.disX * 8 + pic.disY;
       
        //trace(pic.name);
       
        pic.txt_disInfo.text = 
        "(" 
         + pic.disX + 
        "," 
         + pic.disY + 
        ")"
        ;
       
        pic.gotoAndStop (type);
       
        addChild (pic);
       
        pic.addEventListener (MouseEvent.CLICK,picCLK);
       
        }
       
        //点击事件具体处理部分
       
        function 
         picCLK (_evt:MouseEvent) {
       
        //trace(_evt.currentTarget.name);
       
        if 
         (! clkFlag) {
       
        firstObj = _evt.currentTarget as Pic;
       
        clkFlag = 
        true
        ;
       
        } 
        else 
         if 
         (firstObj == (_evt.currentTarget as Pic)) {
       
        //trace ("the same one");
       
        /*firstObj = _evt.currentTarget as Pic;
       
        clkFlag = true;*/
       
        clkFlag = 
        true
        ;
       
        } 
        else 
         {
       
        secondObj = _evt.currentTarget as Pic;
       
        if 
         (checkTwoObj()) {
       
        matchSucc ();
       
        } 
        else 
         {
       
        matchFailed ();
       
        }
       
        aryCrossPath = [];
       
        }
       
        /*trace ("-------------------------------------------");
       
        trace ("firstObj"+firstObj.pType);
       
        trace ("secondObj"+secondObj.pType);
       
        trace ("firstObj.disX"+firstObj.disX);
       
        trace ("firstObj.disY"+firstObj.disY);
       
        trace ("secondObj.disX"+secondObj.disX);
       
        trace ("secondObj.disY"+secondObj.disY);
       
        trace ("-------------------------------------------");*/
       
        }
       
        //判断firstObj和secondObj是否可以消除
       
        function 
         checkTwoObj ():Boolean {
       
        if 
         (matchTwoObj()) {
       
        //trace ("same type");
       
        if 
         (testCrossAbleXY(firstObj,secondObj)) {
       
        return 
         true
        ;
       
        }
       
        }
       
        return 
         false
        ;
       
        }
       
        function 
         matchFailed () {
       
        firstObj = secondObj;
       
        secondObj = 
        null
        ;
       
        clkFlag = 
        true
        ;
       
        //trace(aryCrossPath);
       
        }
       
        function 
         matchSucc () {
       
        var 
         firstPathName = 
        "path" 
         + firstObj.name.substr(3);
       
        var 
         firstPath:Path = getChildByName(firstPathName) as Path;
       
        var 
         secondPathName = 
        "path" 
         + secondObj.name.substr(3);
       
        var 
         secondPath:Path = getChildByName(secondPathName) as Path;
       
        setCrossFlag (firstObj.disX,firstObj.disY,firstPath,
        true
        );
       
        setCrossFlag (secondObj.disX,secondObj.disY,secondPath,
        true
        );
       
        removeChild (firstObj);
       
        removeChild (secondObj);
       
        firstObj = 
        null
        ;
       
        secondObj = 
        null
        ;
       
        clkFlag = 
        false
        ;
       
        drawLine(aryCrossPath);
       
        //trace(aryCrossPath);
       
        }
       
        //连线函数
       
        function 
         drawLine(_ary:Array){
       
        //trace("drawLine");
       
        var 
         lineSP:Shape = 
        new 
         Shape();
       
        lineSP.graphics.beginFill(0x000000);
       
        lineSP.graphics.lineStyle(1, 0x000000);
       
        //lineSP.graphics.moveTo(_ary[0][0]*PICSIZE+0.5*PICSIZE,_ary[0][1]*PICSIZE+0.5*PICSIZE);
       
        for
        (
        var 
         i:uint = 0; i<(_ary.length-1); i++){
       
        lineSP.graphics.moveTo(_ary[i][0]*PICSIZE+0.5*PICSIZE,_ary[i][1]*PICSIZE+0.5*PICSIZE);
       
        lineSP.graphics.lineTo(_ary[(i+1)][0]*PICSIZE+0.5*PICSIZE,_ary[(i+1)][1]*PICSIZE+0.5*PICSIZE);
       
        //trace(_ary[i][0],_ary[i][1]);
       
        }
       
        lineSP.graphics.endFill();
       
        addChild(lineSP);
       
        setTimeout(clearLine,1000,lineSP);
       
        }
       
        //移除连线
       
        function 
         clearLine(_lineSP:Shape){
       
        _lineSP.graphics.clear();
       
        }
       
        //判断firstObj和secondObj是否是同一个类型的图，是返回true，不是返回false
       
        function 
         matchTwoObj ():Boolean {
       
        if 
         (firstObj.pType == secondObj.pType) {
       
        return 
         true
        ;
       
        } 
        else 
         {
       
        return 
         false
        ;
       
        }
       
        }
       
        //同一列方向(X相同时)的直接连通检测
       
        function 
         testCrossAbleX (disX:uint, firstObjDisY:uint, secondObjDisY:uint):Boolean {
       
        var 
         maxY = Math.max(firstObjDisY,secondObjDisY);
       
        var 
         minY = Math.min(firstObjDisY,secondObjDisY);
       
        if 
         ((maxY - minY)>1) {
       
        for 
         (
        var 
         i:uint = minY+1; i< maxY; i++) {
       
        if 
         (! aryPath[disX][i]) {
       
        //trace ("testCrossAbleX failed");
       
        return 
         false
        ;
       
        }
       
        }
       
        }
       
        //trace ("testCrossAbleX succ");
       
        return 
         true
        ;
       
        }
       
        //同一行方向(Y相同时)的直接连通检测
       
        function 
         testCrossAbleY (disY:uint, firstObjDisX:uint, secondObjDisX:uint):Boolean {
       
        var 
         maxX = Math.max(firstObjDisX,secondObjDisX);
       
        var 
         minX = Math.min(firstObjDisX,secondObjDisX);
       
        if 
         ((maxX - minX)>1) {
       
        for 
         (
        var 
         i:uint = minX+1; i< maxX; i++) {
       
        if 
         (! aryPath[i][disY]) {
       
        //trace ("testCrossAbleY failed");
       
        return 
         false
        ;
       
        }
       
        }
       
        }
       
        //trace ("testCrossAbleY succ");
       
        return 
         true
        ;
       
        }
       
        //firstObj和secondObj不同列也不同行时的检测
       
        function 
         testCrossAbleXY (firstObj:Pic, secondObj:Pic):Boolean {
       
        var 
         aryFlag1:Boolean = 
        false
        ;
       
        var 
         aryFlag2:Boolean = 
        false
        ;
       
        if 
         ((firstObj.disX == secondObj.disX && testCrossAbleX(firstObj.disX,firstObj.disY,secondObj.disY)) || (firstObj.disY == secondObj.disY && testCrossAbleY(firstObj.disY,firstObj.disX,secondObj.disX))) {
       
        var 
         aryP1:Array = [firstObj.disX,firstObj.disY];
       
        var 
         aryP2:Array = [secondObj.disX,secondObj.disY];
       
        aryCrossPath.push(aryP1);
       
        aryCrossPath.push(aryP2);
       
        return 
         true
        ;
       
        } 
        else 
         {
       
        for 
         (
        var 
         i:uint = 0; i<HEIGHTNUM; i++) {
       
        var 
         flagH1:Boolean;
       
        var 
         flagH2:Boolean;
       
        var 
         flagH3:Boolean;
       
        if 
         (aryPath[firstObj.disX][i]) {
       
        flagH1 = testCrossAbleX(firstObj.disX,i,firstObj.disY);
       
        if 
         (i == secondObj.disY) {
       
        flagH2 = testCrossAbleY(i,firstObj.disX,secondObj.disX);
       
        } 
        else 
         {
       
        flagH2 = aryPath[secondObj.disX][i] && testCrossAbleY(i,firstObj.disX,secondObj.disX);
       
        }
       
        flagH3 = testCrossAbleX(secondObj.disX,i,secondObj.disY);
       
        //aryFlag1[i] = (testCrossAbleX(firstObj.disX,i,firstObj.disY) && aryPath[firstObj.disX][i]) && (testCrossAbleY(i,firstObj.disX,secondObj.disX) && aryPath[secondObj.disY][i]) && testCrossAbleX(secondObj.disX,i,secondObj.disY);
       
        aryFlag1 = aryFlag1 || (flagH1 && flagH2 && flagH3);
       
        if 
         (aryFlag1) {
       
        var 
         aryPx1:Array = [firstObj.disX,firstObj.disY];
       
        var 
         aryPx2:Array = [firstObj.disX,i];
       
        var 
         aryPx3:Array = [secondObj.disX,i];
       
        var 
         aryPx4:Array = [secondObj.disX,secondObj.disY];
       
        aryCrossPath.push(aryPx1);
       
        aryCrossPath.push(aryPx2);
       
        aryCrossPath.push(aryPx3);
       
        aryCrossPath.push(aryPx4);
       
        return 
         true
        ;
       
        }
       
        }
       
        }
       
        for 
         (
        var 
         j:uint = 0; j<WIDTHNUM; j++) {
       
        var 
         flagW1:Boolean;
       
        var 
         flagW2:Boolean;
       
        var 
         flagW3:Boolean;
       
        if 
         (aryPath[j][firstObj.disY]) {
       
        flagW1 = testCrossAbleY(firstObj.disY,j,firstObj.disX);
       
        if 
         (j == secondObj.disX) {
       
        flagW2 = testCrossAbleX(j,firstObj.disY,secondObj.disY);
       
        } 
        else 
         {
       
        flagW2 = aryPath[j][secondObj.disY] && testCrossAbleX(j,firstObj.disY,secondObj.disY);
       
        }
       
        flagW3 = testCrossAbleY(secondObj.disY,j,secondObj.disX);
       
        aryFlag2 = aryFlag2 || (flagW1 && flagW2 && flagW3);
       
        if 
         (aryFlag2) {
       
        var 
         aryPy1:Array = [firstObj.disX,firstObj.disY];
       
        var 
         aryPy2:Array = [j,firstObj.disY];
       
        var 
         aryPy3:Array = [j,secondObj.disY];
       
        var 
         aryPy4:Array = [secondObj.disX,secondObj.disY];
       
        aryCrossPath.push(aryPy1);
       
        aryCrossPath.push(aryPy2);
       
        aryCrossPath.push(aryPy3);
       
        aryCrossPath.push(aryPy4);
       
        return 
         true
        ;
       
        }
       
        }
       
        }
       
        }
       
        aryCrossPath= [];
       
        return 
         false
        ;
       
        }

Pic类就是图片了,这里图方便我在库里丢了个元件弄了8桢,每桢画了不一样的颜色.
该类有3个属性,所在列数disX,所在行数disY,图片类型pType.

 
        package{
       
        import flash.display.MovieClip;
       
        public class Pic extends MovieClip{
       
        public 
        var 
         disX;
       
        public 
        var 
         disY;
       
        public 
        var 
         pType;
       
        public 
        function 
         Pic(){}
       
        }