FLASH连连看算法分析及源代码

2024-02-05 21:58
文章标签 算法 分析 源代码 flash 连连看

本文主要是介绍FLASH连连看算法分析及源代码，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

做FLASH连连看有特别之处，下面我们就详细分析FLASH连连看的算法。

在做连连看之前，我们根据折线数的不同分为3种情况：

    第一种情况：


如图，方块1与方块2 在同一水平线上，方块1与方块3在同一垂直线上，这就是我们的第一种情况：

在实际应用时，我们在1和2之间或1和3之间实例化一条线段，用hitTestObject来测试，如果与这条线段相交的图片个数小于等于2，那么这两个图片就是连通的。

第二种情况：

就是2和3 的关系了，在2和3之间实例化四条线段，两个水平的，两个垂直的，如下图所示：


与A相交的图片数加上与B相交的图片数小于等于2或者与C相交的图片数加上与D相交的图片数小于等于2，那么这两个图片就是连通的。

第三种情况：


第三种情况主要与前两种情况配合使用，如果前两种情况测试不成功，那么直接跳转到第三种情况，如果第三种情况测试依然不成功，那么这两个图片不连通，也就是说用户进行了一次错误操作。

第三种情况比较复杂，测试两个图片是否连通分为两种情况，一种是A线段是水平的(垂直扫描)，另一种是A线段是垂直的(水平扫描)。

1. A线段是水平的，我们要平均间隔垂直扫描并实例化A线段，只有在测试到与A相交的图片数为0时，跳出扫描的循环，并且实例化B线段和C线段，如果与B线段相交的图片数加上与C线段相交的图片数小于等于2，则两个图片连通。

2. A线段是垂直的，算法与上者相同，只是扫描的方向不同。

好了，下面我们来亲手做一个简单的连连看。

我们这个连连看很简单，只要按照下面的操作就可以了。

若要运行此示例，请确保在FLASH文件同目录下有一个images文件夹，其中有1.gif,2.gif,3.gif...40.gif共40个32*32像素的gif格式的图片。

打开flash cs3，新建一个FLASH文档，在文档类中填写simplellk，在同目录下新建一个AS文件，名为simplellk.as，在其中输入以下代码：

package {
/**
版权所有 粉色男孩
2008-8-9
连连看原始模型，供AS3交流所用
*/
import flash.display.Sprite;
import flash.display.Loader;
import flash.net.URLRequest;
public class simplellk extends Sprite {
   private var myllk:llk;
   private var myllkarr:Array=new Array;
   private var image:Loader;
   public function simplellk():void {
    setlisteners();
    addllk();
   }
   private function setlisteners():void {
    stage.addEventListener("mouseDown",click_stage);
    stage.addEventListener("keyUp",keyup);
   }
   private function keyup(event):void{
    if(event.keyCode==116){
     pl();
    }
   }
   private function addllk():void {
    for (var i:int=0; i<80; i++) {
     myllk=new llk;
     image=new Loader;
     image.load(new URLRequest("images/"+((i%40)+1)+".gif"));
     myllk.addChild(image);
     myllk.x=30+(i%10)*40;
     myllk.y=30+Math.floor(i/10)*40;
     myllkarr.push(myllk);
     addChild(myllk);
    }
    pl();//reset
   }
   private function click_stage(event):void {
    for (var i in myllkarr) {
     if (myllkarr[i].hitTestPoint(mouseX,mouseY)) {
      myllkarr[i].selected=!myllkarr[i].selected;
      myllkarr[i].show_selected();
      for (var j in myllkarr) {
       if (j!=i&&myllkarr[j].selected&&j%(myllkarr.length/2)==i%(myllkarr.length/2)) {
        if (testbylevel(i,j)) {
         myllkarr[i].removethis();
         myllkarr[j].removethis();
         if (i>j) {
          myllkarr.splice(i,1);
          myllkarr.splice(j,1);
         } else {
          myllkarr.splice(j,1);
          myllkarr.splice(i,1);
         }
         break;
        } else {
         myllkarr[i].selected=false;
         myllkarr[i].show_selected();
         myllkarr[j].selected=false;
         myllkarr[j].show_selected();
        }
       } else {
        if (j!=i) {
         myllkarr[j].selected=false;
         myllkarr[j].show_selected();
        }
       }
      }
      break;
     }
    }
   }
   private var plarr:Array=new Array;
   private function pl():void {
    //reset
    plarr.splice(0,plarr.length);
    function cxpl(aa:int):void {
     myllkarr[aa].x=30 + Math.floor(Math.random() * 10) * 40;
     myllkarr[aa].y=30 + Math.floor(Math.random() * 8) * 40;
     for (var j:int=0; j < plarr.length; j++) {
      if (myllkarr[aa].x == plarr[j].x && myllkarr[aa].y == plarr[j].y) {
       cxpl(aa);
       break;
      }
     }
    }
    for (var i:int=0; i < myllkarr.length; i++) {
     cxpl(i);
     plarr.push(myllkarr[i]);
    }
   }
   private function testbylevel(a:Number,b:Number):Boolean {
    //测试是否连通并返回相关布尔值
    var unit:Boolean=false;//定义连通初值为false;
    var js:int=0;//计数
    if (myllkarr[a].y == myllkarr[b].y || myllkarr[a].x == myllkarr[b].x) {
     var sprite5:Sprite=new Sprite;
     sprite5.graphics.moveTo(myllkarr[a].x + 16,myllkarr[a].y + 16);
     sprite5.graphics.lineTo(myllkarr[b].x + 16,myllkarr[b].y + 16);
     addChild(sprite5);
     js=0;
     for (var i in myllkarr) {
      if (myllkarr[i].hitTestObject(sprite5)) {
       js++;
       if (js > 2) {
        break;
       }
      }
     }
     if (js <= 2) {
      unit=true;
     } else {
      unit=testlevelthird(a,b);
     }
     sprite5.graphics.clear();
    } else {
     var sprite1:Sprite=new Sprite;
     var sprite2:Sprite=new Sprite;
     var sprite3:Sprite=new Sprite;
     var sprite4:Sprite=new Sprite;
     var test1:Boolean=false;
     var test2:Boolean=false;

     sprite1.graphics.moveTo(myllkarr[a].x + 10,myllkarr[a].y + 10);
     sprite1.graphics.lineTo(myllkarr[b].x + 10,myllkarr[a].y + 10);

     sprite2.graphics.moveTo(myllkarr[b].x + 10,myllkarr[a].y + 10);
     sprite2.graphics.lineTo(myllkarr[b].x + 10,myllkarr[b].y + 10);

     sprite3.graphics.moveTo(myllkarr[a].x + 10,myllkarr[a].y + 10);
     sprite3.graphics.lineTo(myllkarr[a].x + 10,myllkarr[b].y + 10);

     sprite4.graphics.moveTo(myllkarr[a].x + 10,myllkarr[b].y + 10);
     sprite4.graphics.lineTo(myllkarr[b].x + 10,myllkarr[b].y + 10);

     addChild(sprite1);
     addChild(sprite2);
     addChild(sprite3);
     addChild(sprite4);
     js=0;
     for (var d in myllkarr) {
      if (myllkarr[d].hitTestObject(sprite1) || myllkarr[d].hitTestObject(sprite2)) {
       js++;
       if (js > 2) {
        break;
       }
      }
     }
     if (js <= 2) {
      test1=true;
     }
     js=0;
     for (var e in myllkarr) {
      if (myllkarr[e].hitTestObject(sprite3) || myllkarr[e].hitTestObject(sprite4)) {
       js++;
       if (js > 2) {
        break;
       }
      }
     }
     if (js <= 2) {
      test2=true;
     }
     if (test1 || test2) {
      unit=true;
     } else {
      unit=testlevelthird(a,b);
     }
     sprite1.graphics.clear();
     sprite1.graphics.clear();
     sprite3.graphics.clear();
     sprite4.graphics.clear();
    }
    return unit;
   }
   private function testlevelthird(c:Number,d:Number):Boolean {
    var unit:Boolean=false;
    var js:int=0;//计数参量
    var sprite7:Sprite;
    var sprite10:Sprite;
    var test1:Boolean=false;
    var test2:Boolean=false;
    var test3:Boolean=false;
    var test4:Boolean=false;
    for (var kk:int=0; kk < 10; kk++) {
     sprite10=new Sprite ;
     sprite10.graphics.moveTo(myllkarr[c].x + 16,6 + 40 * kk);
     sprite10.graphics.lineTo(myllkarr[d].x + 16,6 + 40 * kk);
     addChild(sprite10);
     js=0;
     for (var ff in myllkarr) {
      if (myllkarr[ff].hitTestObject(sprite10)) {
       js++;
       break;
      }
     }
     if (js == 0) {
      var sprite11:Sprite=new Sprite;
      sprite11.graphics.moveTo(myllkarr[c].x + 16,6 + 40 * kk);
      sprite11.graphics.lineTo(myllkarr[c].x + 16,myllkarr[c].y + 16);
      addChild(sprite11);
      js=0;
      for (var qq in myllkarr) {
       if (myllkarr[qq].hitTestObject(sprite11)) {
        js++;
        if (js > 1) {
         break;
        }
       }
      }
      if (js <= 1) {
       test3=true;
      } else {
       test3=false;
      }
      var sprite12:Sprite=new Sprite;
      sprite12.graphics.moveTo(myllkarr[d].x + 16,6 + 40 * kk);
      sprite12.graphics.lineTo(myllkarr[d].x + 16,myllkarr[d].y + 16);
      addChild(sprite12);
      js=0;
      for (var ww in myllkarr) {
       if (myllkarr[ww].hitTestObject(sprite12)) {
        js++;
        if (js > 1) {
         break;
        }
       }
      }
      if (js <= 1) {
       test4=true;
      } else {
       test4=false;
      }
      if (test3 && test4) {
       unit=true;
       sprite11.graphics.clear();
       sprite12.graphics.clear();
       sprite10.graphics.clear();
       break;
      }
      sprite11.graphics.clear();
      sprite12.graphics.clear();
     }
     sprite10.graphics.clear();
    }
    for (var ii:int=0; ii < 12; ii++) {
     sprite7=new Sprite ;
     sprite7.graphics.moveTo(6 + 40 * ii,myllkarr[c].y + 16);
     sprite7.graphics.lineTo(6 + 40 * ii,myllkarr[d].y + 16);
     addChild(sprite7);
     js=0;
     for (var jj in myllkarr) {
      if (myllkarr[jj].hitTestObject(sprite7)) {
       js++;
       break;
      }
     }
     if (js == 0) {
      var sprite8:Sprite=new Sprite;
      sprite8.graphics.moveTo(6 + 40 * ii,myllkarr[c].y + 16);
      sprite8.graphics.lineTo(myllkarr[c].x + 16,myllkarr[c].y + 16);
      addChild(sprite8);
      js=0;
      for (var pp in myllkarr) {
       if (myllkarr[pp].hitTestObject(sprite8)) {
        js++;
        if (js > 1) {
         break;
        }
       }
      }
      if (js <= 1) {
       test1=true;
      } else {
       test1=false;
      }
      var sprite9:Sprite=new Sprite;
      sprite9.graphics.moveTo(6 + 40 * ii,myllkarr[d].y + 16);
      sprite9.graphics.lineTo(myllkarr[d].x + 16,myllkarr[d].y + 16);
      addChild(sprite9);
      js=0;
      for (var ll in myllkarr) {
       if (myllkarr[ll].hitTestObject(sprite9)) {
        js++;
        if (js > 1) {
         break;
        }
       }
      }
      if (js <= 1) {
       test2=true;
      } else {
       test2=false;
      }
      if (test1 && test2) {
       unit=true;
       sprite8.graphics.clear();
       sprite9.graphics.clear();
       sprite7.graphics.clear();
       break;
      }
      sprite8.graphics.clear();
      sprite9.graphics.clear();
     }
     sprite7.graphics.clear();
    }
    return unit;
   }
}
}


import flash.display.Sprite;
class llk extends Sprite {
private var mouseover:Sprite;
private var select:Sprite;
public var selected:Boolean=false;
public function llk():void {
   this.buttonMode=true;
   setface();//设置鼠标事件界面
   configlisteners();
}
//------------------------------------------------------------------
//private functions
private function setface():void {
   mouseover = new Sprite;
   mouseover.graphics.beginFill(0x0000FF, .3);
   mouseover.graphics.drawRect(0, 0, 32, 32);
   mouseover.mouseEnabled=false;

   select = new Sprite;
   select.graphics.beginFill(0xFF0000, .3);
   select.graphics.drawRect(0, 0, 32, 32);
   select.mouseEnabled=false;

}
private function configlisteners():void {
   this.addEventListener("mouseOver", over_this);
   this.addEventListener("mouseOut", out_this);
}
private function out_this(event):void {
   if (!selected) {
    try {
     removeChild(mouseover);
    } catch (error:Error) {
    }
   }
}
private function over_this(event):void {
   if (!selected) {
    addChild(mouseover);
   }
}
//-------------------------------------------------------------------
//public functions
public function show_selected():void {
   if (selected) {
    addChild(select);
    try {
     removeChild(mouseover);
    } catch (error:Error) {
    }
   } else {
    try {
     removeChild(mouseover);
    } catch (error:Error) {
    }
    try {
     removeChild(select);
    } catch (error:Error) {
    }
   }
}
public function removethis():void {
   this.removeEventListener("mouseOver", over_this);
   this.removeEventListener("mouseOut", out_this);
   parent.removeChild(this);
}
}

好了，Ctrl+enter就可以看到效果了，按F5可以重排。

=========================================
原作者：粉色男孩http://hi.baidu.com/fsnhf

这篇关于FLASH连连看算法分析及源代码的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/682286。

相关文章

Android kotlin中 Channel 和 Flow 的区别和选择使用场景分析

Android kotlin中 Channel 和 Flow 的区别和选择使用场景分析

《Androidkotlin中Channel和Flow的区别和选择使用场景分析》Kotlin协程中,Flow是冷数据流,按需触发,适合响应式数据处理；Channel是热数据流,持续发送,支持... 目录一、基本概念界定FlowChannel二、核心特性对比数据生产触发条件生产与消费的关系背压处理机制生命周期
阅读更多...
怎样通过分析GC日志来定位Java进程的内存问题

怎样通过分析GC日志来定位Java进程的内存问题

《怎样通过分析GC日志来定位Java进程的内存问题》：本文主要介绍怎样通过分析GC日志来定位Java进程的内存问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录一、GC 日志基础配置1. 启用详细 GC 日志2. 不同收集器的日志格式二、关键指标与分析维度1.
阅读更多...
Java中的雪花算法Snowflake解析与实践技巧

Java中的雪花算法Snowflake解析与实践技巧

《Java中的雪花算法Snowflake解析与实践技巧》本文解析了雪花算法的原理、Java实现及生产实践,涵盖ID结构、位运算技巧、时钟回拨处理、WorkerId分配等关键点,并探讨了百度UidGen... 目录一、雪花算法核心原理1.1 算法起源1.2 ID结构详解1.3 核心特性二、Java实现解析2.
阅读更多...
MySQL中的表连接原理分析

MySQL中的表连接原理分析

《MySQL中的表连接原理分析》：本文主要介绍MySQL中的表连接原理分析,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录1、背景2、环境3、表连接原理【1】驱动表和被驱动表【2】内连接【3】外连接【4编程】嵌套循环连接【5】join buffer4、总结1、背景
阅读更多...
python中Hash使用场景分析

python中Hash使用场景分析

《python中Hash使用场景分析》Python的hash()函数用于获取对象哈希值,常用于字典和集合,不可变类型可哈希,可变类型不可,常见算法包括除法、乘法、平方取中和随机数哈希,各有优缺点,需根... 目录python中的 Hash除法哈希算法乘法哈希算法平方取中法随机数哈希算法小结在Python中，
阅读更多...
Java Stream的distinct去重原理分析

Java Stream的distinct去重原理分析

《JavaStream的distinct去重原理分析》Javastream中的distinct方法用于去除流中的重复元素,它返回一个包含过滤后唯一元素的新流,该方法会根据元素的hashcode和eq... 目录一、distinct 的基础用法与核心特性二、distinct 的底层实现原理1. 顺序流中的去重
阅读更多...
关于MyISAM和InnoDB对比分析

关于MyISAM和InnoDB对比分析

《关于MyISAM和InnoDB对比分析》：本文主要介绍关于MyISAM和InnoDB对比分析,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录开篇：从交通规则看存储引擎选择理解存储引擎的基本概念技术原理对比1. 事务支持：ACID的守护者2. 锁机制：并发控制的艺
阅读更多...
MyBatis Plus 中 update_time 字段自动填充失效的原因分析及解决方案(最新整理)

MyBatis Plus 中 update_time 字段自动填充失效的原因分析及解决方案(最新整理)

《MyBatisPlus中update_time字段自动填充失效的原因分析及解决方案(最新整理)》在使用MyBatisPlus时,通常我们会在数据库表中设置create_time和update... 目录前言一、问题现象二、原因分析三、总结：常见原因与解决方法对照表四、推荐写法前言在使用 MyBATis
阅读更多...
Python主动抛出异常的各种用法和场景分析

Python主动抛出异常的各种用法和场景分析

《Python主动抛出异常的各种用法和场景分析》在Python中,我们不仅可以捕获和处理异常,还可以主动抛出异常,也就是以类的方式自定义错误的类型和提示信息,这在编程中非常有用,下面我将详细解释主动抛... 目录一、为什么要主动抛出异常？二、基本语法：raise关键字基本示例三、raise的多种用法1. 抛
阅读更多...
github打不开的问题分析及解决

github打不开的问题分析及解决

《github打不开的问题分析及解决》：本文主要介绍github打不开的问题分析及解决,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录一、找到github.com域名解析的ip地址二、找到github.global.ssl.fastly.net网址解析的ip地址三
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2