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

最新推荐文章于 2024-02-26 17:00:38 发布

stoneson

最新推荐文章于 2024-02-26 17:00:38 发布

阅读量1.7k

点赞数

分类专栏： FLEX 文章标签： flash 算法 function 测试 image c

本文链接：https://blog.csdn.net/stoneson/article/details/6043622

版权

FLEX 专栏收录该内容

27 篇文章 0 订阅

订阅专栏

做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

stoneson

关注

0
点赞
踩
8

收藏

觉得还不错? 一键收藏
打赏
0
评论
FLASH连连看算法分析及源代码

 做FLASH连连看有特别之处，下面我们就详细分析FLASH连连看的算法。 在做连连看之前，我们根据折线数的不同分为3种情况： 第一种情况： 如图，方块1与方块2 在同一水平线上，方块1与方块3在同一垂直线上，这就是我们的第一种情况： 在实际应用时，我们在1和2之间或1和3之间实例化一条线段，用hitTestObject来测试，如果与这条线段相交的图片个数小于等于2，那么这两个图片就是连通的。 第二种情况
复制链接

扫一扫