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线段是垂直的(水平扫描)。

线段是水平的，咱们要平均距离垂直扫描并实例化A线段，只有在测试到与A相交的图片数为0时，跳出扫描的循环，而且实例化B线段和C线段，若是与B线段相交的图片数加上与C线段相交的图片数小于等于2，那么两个图片连通。

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

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

咱们那个连连看很简单，只要依照下面的操作就能够够了。

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

打开flash cs3，新建一个FLASH文档，在文档类中填写simplellk，在同目录下新建一个AS文件，名为，在其中输入以下代码：
package {
/**连连看原始模型，供AS3交流所用
*/
import
import
import
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 { ("mouseDown",click_stage);
("keyUp",keyup);
}
private function keyup(event):void{
if==116){
pl();
}
}
private function addllk():void {
for (var i:int=0; i<80; i++) {
myllk=new llk;
image=new Loader;
(new URLRequest("images/"+((i%40)+1)+".gif")); (image);
=30+(i%10)*40;
=30+(i/10)*40;
(myllk);
addChild(myllk);
}
pl();itTestPoint(mouseX,mouseY)) {
myllkarr[i].selected=!myllkarr[i].selected; myllkarr[i].show_selected();
for (var j in myllkarr) {
if (j!=i&&myllkarr[j].selected&&j%2)==i%2)) { if (testbylevel(i,j)) {
myllkarr[i].removethis();
myllkarr[j].removethis();
if (i>j) {
(i,1);
(j,1);
} else {
(j,1);
(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 {
=30 + () * 10) * 40;
myllkarr[aa].y=30 + () * 8) * 40;
for (var j:int=0; j < ; j++) {
if (myllkarr[aa].x == plarr[j].x && myllkarr[aa].y == plarr[j].y) { cxpl(aa);
break;
}
}
for (var i:int=0; i < ; i++) {
cxpl(i);
(myllkarr[i]);
}
}
private function testbylevel(a:Number,b:Number):Boolean { == myllkarr[b].y || myllkarr[a].x == myllkarr[b].x) {
var sprite5:Sprite=new Sprite;
+ 16,myllkarr[a].y + 16);
+ 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);
}
} 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;
+ 10,myllkarr[a].y + 10);
+ 10,myllkarr[a].y + 10);
+ 10,myllkarr[a].y + 10);
+ 10,myllkarr[b].y + 10);
+ 10,myllkarr[a].y + 10);
+ 10,myllkarr[b].y + 10);
+ 10,myllkarr[b].y + 10);
+ 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);
}
}
return unit;
}
private function testlevelthird(c:Number,d:Number):Boolean { var unit:Boolean=false;
var js:int=0;itTestObject(sprite10)) {
js++;
break;
}
}
if (js == 0) {
var sprite11:Sprite=new Sprite;
+ 16,6 + 40 * kk);
+ 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;
+ 16,6 + 40 * kk);
+ 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;
break;
}
}
}
for (var ii:int=0; ii < 12; ii++) { sprite7=new Sprite ;
+ 40 * ii,myllkarr[c].y + 16);
+ 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;
+ 40 * ii,myllkarr[c].y + 16);
+ 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;
+ 40 * ii,myllkarr[d].y + 16);
+ 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;
break;
}
}
}
return unit;
}
}
}
import
class llk extends Sprite { private var mouver:Sprite; private var select:Sprite;
public var selected:Boolean=false; public function llk():void {
=true;
setface();;
0, 32, 32);
=false;
select = new Sprite;
.3);
0, 32, 32);
=false;
}
private function configlisteners():void { ("mouseOver", over_this); ("mouseOut", out_this);
}
private function out_this(event):void { if (!selected) {
try {
removeChild(mouver);
} catch (error:Error) {
}
}
}
private function over_this(event):void { if (!selected) {
addChild(mouver);
}
}
//------------------------------------------------------------------- //public functions
public function show_selected():void {
if (selected) {
addChild(select);
try {
removeChild(mouver);
} catch (error:Error) {
}
} else {
try {
removeChild(mouver);
} catch (error:Error) {
}
try {
removeChild(select);
} catch (error:Error) {
}
}
}
public function removethis():void { ("mouseOver", over_this);
("mouseOut", out_this);
(this);
}
}
好了，Ctrl+enter就能够够看到成效了，按F5能够重排。