本文主要是介绍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连连看算法分析及源代码的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
