AS3连连看核心算法详解
连连看
6
using System.Collections; //ArrayList命名空间 private void StartNewGame() { //初始化地图,将地图中所有方块区域位置置为空方块状态 for(int iNum=0;iNum<(m_nCol*m_nRow);iNum++) { m_map[iNum] = BLANK_STATE; } Random r = neWRandom(); //生成随机地图 //将所有匹配成对的动物物种放进一个临时的地图中 ArrayList tmpMap=neWArrayList (); for(int i=0;i<(m_nCol*m_nRow)/4;i++) for(int j=0;j<4;j++) tmpMap.Add(i); //每次从上面的临时地图中取走(获取后并在临时地图删除) //一个动物放到地图的空方块上 for (int i = 0; i < m_nRoW* m_nCol; i++) { //随机挑选一个位置 int nIndex = r.Next() % tmpMap.Count ; //获取该选定物件放到地图的空方块 m_map[i]=(int)tmpMap[nIndex]; //在临时地图除去该动物 tmpMap.RemoveAt(nIndex); } }
} //一个转弯（折点）的联通方式 if(OneCornerLink(x1,y1,x2,y2)) { LType = LinkType.OneCornerType ; return true; } //两个转弯（折点）的联通方式 else if(TwoCornerLink(x1,y1,x2,y2)) { LType = LinkType.TwoCornerType; return true; } return false;
基于深度优先搜索的连连看游戏路径查找算法
【关键词】连 连 看 游 戏 ； 路 径 ； 深 度 优 先 搜 索 ； 栈 ； 轨 迹
连连看原理
用 JAVA 开发游戏连连看其实不管是做软件也好，做游戏也好，只要是写程序，在动手之前是一定会存在需求和分析的，如果不经过一定的分析就开始动手写程序，那么，这个程序一定会很难写下去的，最后的结果可能会导致放弃。
那么，在我们动手之前，让我们先简单的分析一下吧。
由于“连连看”并不是一个我们凭空开发的游戏，并且网上也已经有很多别人已经开发好的版本，因此，对于我们来说，我们已经拥有了一个很好的原型（比如说 QQ 游戏中的“连连看”），分析起来也应该是轻松得多。
由于 QQ 中的“连连看”是网络版，为了开发上的简便，我们先放弃网络功能，做一个简单的单机版就行了。
现在，让我们现在来看一看 QQ 中的连连看吧。
“连连看”的游戏规则其实并不复杂，首先，游戏开始的时候，地图上会有由数张不同的图片随机分散在地图上（并且每张图片会出现偶数次，通常是 4 次），只需要在地图上找出两张相同的图片（点），并且这两个点之前可以用不超过 3 条的直线连接起来就可以消除这两点，如此下去，直到地图上的点全部消除完就算游戏结束，怎么样，规则很简单吧？：）我们的开发就完全按照些规则来吧。
分析游戏规则找出算法通过上面的分析，我们已经知道了游戏规则，可是，我们怎么样去实现呢？其实所谓的实现也就是算法，那我们怎么样找出算法呢？别急，让我们来看一看上图，或者自己动手玩一玩别人做好的。
通过对上图的观察，我们发现，可以将游戏中的地图看作是一个二维数组，其中的所有图片（以下称“点”）可以看作是数组中的一个具体的元素。
那么，游戏中相同的图片可以看作是数组中不同位置两个值相同的元素。
至于直线，让我们给组数中的每一个元素赋一个特殊的值如 0 ，以表示地图上空白的位置。
并且同时规定：当连续的具有该特殊值的点的横向索引或纵向索引相同时，可以认为这是一条直线，比如下图：当数组中两点的值相同并且两点间只需要不超过 3 根直线能连接起来的时候，就让这两点的值变为 0 ，如果数组中全是 0 值的点，就认为游戏已经结束：）怎么样，算法够简单了吧：）用伪代码来描述程序的结构现在，我们用伪代码来描述一下游戏，假设用户开始了游戏：消除两点；上次选择的点 = null ；if ( 地图上已没有可消除的点 ) { 游戏结束；}}else {上次选择的点 = 当前点；}}else {上次选择的点 = 当前点；}}游戏结束；看看有没有什么问题？如果没有问题，我们进入下一步吧：）确定程序需要的模块当伪代码完成后，并且在我们的大脑里转了几圈发现没有问题后，现在就可以开始进行模块的划分工作了。
连连看算法详谈
游戏连连看的算法探究及源码实现（1）------ 综述述---转载时请注明原文出处(/wyw1976)及作者邮箱(wyw1976@)“连连看”是一款老少皆宜、百玩不厌的休闲类小游戏。
各种“连连看”也层出不穷、五花八门，例如“果蔬连连看”、“宠物连连看”、“麻将连连看”等。
各种“连连看”大同小异，无非就是界面图片不同，其核心算法应该是类似的。
闲暇时，自己也编了一个“连连看”小游戏，大约有1000行代码，功能如下：（1）纯C、纯字符界面，下面是截图：（2）10种游戏模式：∙普通模式∙左移模式∙右移模式∙上移模式下移模式∙左右分离模式∙上下分离模式∙水平中线聚集模式∙垂直中线聚集模式中心点聚集（3）随机产生游戏初始布局。
（4）随时进行“死锁”监控（5）“死锁”发生时，重新生成游戏残局（6）“路径输出”。
在连通时，输出连通路径。
（7）支持“自动”和“手动”两种模式。
在“自动”模式中，计算机模拟用户完成整个游戏。
这在算法测试时显得尤为重要，因为靠人工来完成算法的测试，十分低效甚至不可能全覆盖，而“自动”模式中，计算机完成一局的时间只要几秒，很容易发现算法中的漏洞。
（8）支持性能统计。
这对于算法优化很重要。
游戏"连连看"的算法探究及源码实现（2）----- 流程图下面是“连连看”的流程图：说明：（1）在"死锁"判定时，只要找到了一对匹配的点，就立即退出并记录该匹配点对，（在需要提示的时候，只要输出该点对即可）。
（2）如果用户的输入点对是连通的，而且与匹配点对中的任何一个是相同的，则需要重新进行“死锁”判定。
（3）在“连通”判定过程中，会生成连通路径。
（4）“更新游戏布局”包括移动相关的点，及消除匹配点。
（5）“初始布局”和“残局”的处理是不同的，这点我们还会详细说明（6）从上述流程图中，可以看出程序主要包含以下几个模块：∙随机生成游戏初始布局∙“死锁”判定∙随机产生游戏残局∙连通判定∙游戏布局更新∙生成联通路径我们将详细描述以上模块的算法及其实现。
AS3.0算法大全
[AS 功能代码教程15] 点间距离公式 [FL基础理论大师]■[Flash基础理论课16] 矩阵革命 [双重循环]■[AS 功能代码教程14] 鱼眼放大镜 [FL基础理论大师]■[AS 功能代码教程13] 贪吃蛇游戏制作 [FL基础理论大师]■[Flash基础理论课15] 绚酷鼠标 [目标移动]■[Flash基础理论课14] 制作Loading [Loading]■[杂谈四] JavaScript就这么回事 [二次编辑贴]■[AS 功能代码教程12] 填色游戏 [FL基础理论大师]■[Flash基础理论课13] FL记事本 [SharedObject]■[杂谈四] AS代码优化技巧 [综合贴]■[AS 功能代码教程11] 图片转场效果 [FL基础理论大师]■[Flash基础理论课12] 倒计时系统 [getTime]■[杂谈四] 程序员应该学C语言的十个理由■[AS 功能代码教程10] 数据结构排序算法 [FL基础理论大师]■[Flash基础理论课11] AS文本计算器 [文本类]■[AS 功能代码教程09] 点阵字效果 [FL基础理论大师]■[AS 功能代码教程08] BitmapData动态效果 [FL基础理论大师]■[Flash基础理论课10] 缓动效果 [Tween类]■[杂谈三] 微软Silverlight和Flash短兵相接■[AS 功能代码教程07] 百变图 [FL基础理论大师]■[AS 功能代码教程06] AS绘图总结及补充 [FL基础理论大师]■[Flash基础理论课09]满天星及变幻线[MC.onEnterFrame]■[Flash基础理论课08]旋转花朵[for...in]■[游戏赏玩]吸泡泡■[Flash基础理论课07]制作控制滑块[startDrag]■[杂谈二]人类的15个欲望与游戏设计■[AS 功能代码教程04] 进阶三角函数及应用 [FL基础理论大师]■[Flash基础理论课06]制作移动角色[Key类]■[Flash基础理论课05]制作摇奖盘[onEnterFrame]■[AS 功能代码教程05] 打字机效果及字符串概念 [FL基础理论大师] ■[AS 功能代码教程03] 基础三角函数及应用 [FL基础理论大师]■[AS 功能代码教程02]数字魔方及数组概念[FL基础理论大师]■[AS 功能代码教程01]通用延迟代码及FPS概念[FL基理大师原创] ■[Flash基础理论课04] 制作音乐播放器[Sound类]■[Flash基础理论课03]制作简易涂鸦板[画线指令]■[Flash基础理论课02]制作个性鼠标[updateAfterEvent]■[Flash基础理论课01]制作时钟[Date类]■[杂谈一] 什么是真正的Flash高手？希望朋友们多提保贵议建，您的题问和课题将成文我前进的最大动力。
基于Flash as3的“连连看”游戏型课件制作实例
基于Flash as3的“连连看”游戏型课件制作实例通过开发教学小游戏，让学生在游戏中学习，可以使原本枯燥的教学内容变得富有情趣，做到寓教于乐。
现通过Flash cs5制作一个简单的“连连看”小游戏课件，探索Flash as3游戏型课件的制作。
一、创建一个“Movie Clip”类的派生类启动Flash cs5（使用as3的其他Flash版本也可以），新建一个Action Script 3.0类文件，类名输入“llk”，然后在其中输入以下内容（以llk.as为文件名存盘）：package{import flash.display.MovieClip；//导入必要的类import flash.events.MouseEvent；public class llk extends MovieClip{private static var SelectName：String=““，ParentName：String=““；//声明两个静态变量，保存选中的“连连看按钮”实例名和其父影片剪辑实例名public function llk（）{this.addEventListener（MouseEvent.CLICK，f1）；function f1（e：MouseEvent）{if （llk.SelectName == && llk.ParentName ！= ）//选择正确时执行{parent.parent[llk.ParentName][llk.SelectName].gotoAndPlay（3）；//两选项同时闪动gotoAndPlay（3）；parent.parent[llk.ParentName][llk.SelectName].removeEventListener （MouseEvent.CLICK，f1）；//取消两选项的鼠标帧听e.currentTarget.removeEventListener（MouseEvent.CLICK，f1）；llk.SelectName = ““；//清空保存的选中“连连看按钮”实例名}else{if （llk.SelectName ！= ““）{parent.parent[llk.ParentName][llk.SelectName].gotoAndStop（1）；//取消选中状态}llk.SelectName = ；// 保存选中的“连连看按钮”实例名和其父影片剪辑实例名llk.ParentName = ；gotoAndStop（2）；//改变选中状态}}}}}二、创建一个基类为“llk”的影片剪辑元件，作为“连连看按钮”使用在Flash cs5中创建一个ActionScrtip3.0文件，并将其与“llk.as”保存在同一文件夹中。
《连连看》算法c语言演示（自动连连看）
《连连看》算法c语⾔演⽰（⾃动连连看）（图⽚是游戏的⽰意图，来⾃互联⽹，与本⽂程序⽆关）看题⽬就知道是写给初学者的，没需要的就别看了，⾃⼰都觉得怪⽆聊的。
很多游戏的耐玩性都来⾃精巧的算法，特别是⼈⼯智能的⽔平。
⽐如前⼏天看了著名的Alpha GO的算法，⽤了复杂的⼈⼯智能⽹络。
⽽最简单的，可能就是连连看了，所以很多⽼师留作业，直接就是实现连连看。
连连看游戏的规则⾮常简单：1. 两个图⽚相同。
2. 两个图⽚之间，沿着相邻的格⼦画线，中间不能有障碍物。
3. 画线中间最多允许2个转折。
所以算法主要是这样⼏部分：1. ⽤数据结构描述图板。
很简单，⼀个2维的整数数组，数组的值就是图⽚的标志，相同的数字表⽰相同的图⽚。
有⼀个⼩的重点就是，有些连连看的地图中，允许在边界的两个图⽚，从地图外连线消除。
这种情况⼀般需要建⽴的图板尺⼨，⽐实际显⽰的图板，周边⼤⼀个格⼦，从⽽描述可以连线的空⽩外边界。
本例中只是简单的使⽤完整的图板，不允许利⽤边界外连线。
2. ⽣成图板。
通常⽤随机数产⽣图⽚ID来填充图板就好。
⽐较复杂的游戏，会有多种的布局⽅式，例如两个三⾓形。
这种⼀般要⼿⼯编辑图板模板，在允许填充的区域事先⽤某个特定的整数值来标注，随后的随机数填充只填充允许填充的区域。
本例中只是简单的随机填充。
3. 检查连线中的障碍物。
确定有障碍物的关键在于确定什么样的格⼦是空。
通常定义格⼦的值为0就算空。
要求所有的图⽚ID从1开始顺序编码。
复杂的游戏还会定义负数作为特定的标志，⽐如允许填充区之类的。
4. 检查直接连接：两张图⽚的坐标，必然x轴或者y轴有⼀项相同，表⽰两张图⽚在x轴或者y轴的同⼀条线上才可能出现直接连接。
随后循环检查两者之间是否有障碍物即可确定。
5. 检查⼀折连接：与检查直接连接相反，两个图⽚必须不在⼀条直线上，才可能出现⼀折连接，也就是x/y必须都不相同。
随后以两张图⽚坐标，可以形成⼀个矩阵，矩阵的⼀对对⾓是两张图⽚，假设是A/B两点。
《Flash AS3从入门到精通》90天综合课程提纲912
《Flash AS3 从入门到精通》90天综合课程提纲前言：为了更好的满足广大游戏开发爱好者不同层次的需求,解决游戏公司用人要求中注重开发质量和项目经验的问题,天地培训特推出Flash游戏开发，"基础+进阶+实训"的90天综合课程。
基础课程:帮助基础较差的学员学习编程语言的基本用法,系统的学习JavaScript基本语法,以及如何用程序化的思想去分析,思考和设计游戏。
进阶课程（AS3游戏编程）：1.学习FlashProfessional的基本用法,系统的学习AS3基本语法,以及如何用程序化的思想去分析,思考和设计游戏.课程结束后一般学员可独立完成"打砖块"等简单游戏.2.FlashBuilder的用法,继承封装等OOP概念和方法,以及核心显示架构,事件,事件流,位图,声音,网络通信等重要内容,重点是如何使用面向对象的方法去分析,设计和实现一些较复杂的项目.如<雷电>,塔防游戏等.实训课程:主要是模拟现实中游戏公司如何立项,制定项目计划,团队成员之间如何协作开发,如何对项目资源和代码的版本化管理等,让学员在进入公司工作以后,可以很快的融入到公司正常项目中.本阶段课程要求学生在讲师的指导下独立设计和开发一款完整的游戏.学习目标1、打下牢固的编程语法基础，学习面向对象编程思想，能够理解类、对象、继承、多态、接口等OOP 概念，学习简单常用的设计模式；2、建立良好的编程习惯，能够写出高可读性的代码，能够按照规范命名变量、定义方法、流程控制等；3、学习标准的面向对象开发流程，严格按照OOA——OOD——OOP的流程开发应用程序、网页游戏、手机游戏等。
4、熟悉如何与设计师、后台技术工程师协同工作，能熟练掌握常用的Flash开发工具。
第一部分：基础课程一、JavaScript编程语言1.了解什么是程序？目前主流的编程语言有哪些。
了解从事IT行业所应具备的技能和知识。
连连看算法及实现原理详解(C++源码)
void FunctionalModule::m_ColorToNum(HWND hwnd) //把像素转换为数组格式
{
HDC hdc=GetDC(hwnd);
break;
default:
break;
}
}
}
}
}
}
}
}
}
}
////////////////////////////////////////////////////////////////////////
int icolor=0;
COLORREF ccolor1,ccolor2;
for (int n1=0,nx=10;n1<5;n1++,nx-=5)
{
for (int m1=0,my=10;m1<5;m1++,my-=5)
int m_LeftTop(int ax,int ay,int bx,int by); //左上 11
int m_YLeft(int ax,int ay,int bx,int by); //y左 12
int m_LeftBottom(int ax,int ay,int bx,int by); //左下 13
{
ptLineOne.x=0;ptLineOne.y=0;//转折点的两个坐标设为0
ptLineTwo.x=0;ptLineTwo.y=0;
numTotal=(xLast+1)*(yLast+1);//图案总的个数
【龙图教育】细谈AS3程序性能优化
细谈AS3程序性能优化程序性能优化是很多程序的心头病，也是很多新手望而却步的高深领域，笔者根据自己多年的开发经验以及同行前辈的指导，现总结以下优化方面：1.合理创建对象，减少对象的数目以降低gc使用完的对象，flash player的垃圾回器会回收他们的内存来重新使用。
不幸的是，这个过程是非常缓慢的而且我们不能控制它什么时候执行。
所以，尽量重用已经存在的对象而减少使用new来声明新的对象。
对这方面有帮助的一个技术是free lists。
2.对逻辑算法进行优化，减少多余的计算无论对于那一种程序，好的算法总是非常重要的，而且能够极大地提高程序性能，所以任何性能的优化第一步就是从算法或者说程序逻辑的优化开始，检查自己的程序是否有多余的运算，是否在没有必要的时候做了无用功，往往从这些方面就能找到那些导致性能低下的地方。
3.使用flash的源生代码代替as3一般情况下，使用flash player的原生代码做一些大负荷的工作要比使用as3去做好的多。
因为和调用flash player api(flash包里面的所有东西)里面的方法相比，在vm(虚拟机)里运行你自己的as3代码势必会带来一些间接成本。
不适用这个规则的例外是，api有时会做你不想做的事情，比如分配内存4.减少内存分配以降低gc除了你预料到的内存分配，比如通过使用某个新的操作触发某个事件，还有很多隐藏的分配，比如关联的字符串对象、flash player自己创建的对象，如事件。
这些分配很慢，使用完了回收他们更慢，所以试着去掉这样的分配。
5.不要使用任何动态的东西这包括动态的函数(如无特征的函数和被声明为局部变量的函数)，如Object和MovieClip这样的对象，用”[]“操作符访问字段、无类型的变量。
这些都比使用相应的静态量(如正规的函数、非动态类、”.”运算符、有类型的变量)要慢的多。
6.把更多的事情交给gpu现在在flash里面(fp11)我们除了可以使用cpu外，还可以使用显卡的gpu。
AS3连连看核心算法详解
[教程] 连连看核心算法详解最近做了个连连看游戏，综合网上各种不同的思路，整理出了个人认为大家都比较好理解的一套思路。
游戏规则：很简单,就是点中两个互相匹配并且可以通过不多于两个折点的折线连在一起的方块后,这两个方块就可以消掉。
(说明：下面的行和列按照现实的行和列,并不是按照flash坐标系的坐标，请大家按需转换)连通算法：1.直连型2.一折型3.两折型下面我们来分析每一种情况：直连型直连性又分为两种情况：横向直连，纵向直连。
首先是横向检测：a(1,2) , b(1,7)1.private function horizon(a:Point,b:Point):Boolean2.{3. if (a.x == b.x && a.y == b.y) return false; //如果点击的是同一个图案，直接返回false;4. var x_start:int = a.y < b.y?a.y:b.y; //获取a,b中较小的y值5. var x_end:int = a.y < b.y?b.y:a.y; //获取a,b中较大的值6. //遍历a,b之间是否通路，如果一个不是就返回false;7. for (var i:int = x_start + 1; i < x_end;i ++ )8. {9. if (mapData[a.x][i] != 0)10. {11. return false;12. }13. }14. return true;15.}16.其次是纵向检测：1.a(1,1) , b(4,1)2.3.private function vertical(a:Point,b:Point):Boolean4.{5. if (a.x == b.x && a.y == b.y) return false;6. var y_start:int = a.x < b.x?a.x:b.x;7. var y_end:int = a.x < b.x?b.x:a.x;8. for (var i:int = y_start + 1; i < y_end; i ++ )9. {10. if (mapData[i][a.y] != 0)11. {12. return false;13. }14. }15. return true;16.}一个拐角的检测如果一个拐角能连通的话，则必须存在C、D两点。
连连看原理
用 JAVA 开发游戏连连看(注：这篇文章是在2004.12完成的，当时是为了向《电脑爱好者》投稿，这是原稿，由于此杂志面向的读者原因，因此文章中有些地方显得过“白”，在此后，稿子经过两次修改，虽然最终得以发表，但已改得基本上没有太多的技术性了，而且两次改稿下来，一共写了近6万字，累~~~，现在将其略作修改放在主页上，希望对大家有所帮助)提起 JAVA ，相信大家也不会陌生了吧， JAVA 是一门相当优秀的语言。
目前 JAVA 领域 J2EE 、 JSP 、STRUTS 等技术不知有多么的热门，他们的主要用途是用来进行企业开发， J2ME 也由于能够被大量的移动设备所支持，因此，也有不少的程序，特别是游戏是在 J2ME 平台上开发的，反而是 J2SE ，似乎只是被人们用来做一做程序界面的，就连 APPLET 也很少有人使用了（有了 FLASH ，谁还用 APPLET 啊）。
用 JAVA 来开发桌面平台的游戏，似乎很少有人这么做，也可能大家一想到做游戏都会想到 C 、 C++ 、汇编等。
前段日子我迷上的 QQ 游戏中的“连连看”，游戏之余，突发奇想，也想自己用做一个试试，经过十来天的奋战，终于完成了。
我选择了 JAVA 来开发这个游戏，之所以选择 JAVA ，是因为：1.很少有人用 JAVA 来开发桌面游戏，是因为 JAVA 在网络方面的强大优势使人们忽略了 JAVA在桌面平台上的开发，特别是游戏方面，而并不是因为 JAVA 做不到，而我，却希望通过我的尝试来告诉大家：原来 JAVA 也能做出漂亮的桌面游戏的（我可不是在夸我的程序：））2.由于 JAVA 生来就是为网络服务的，因此，一旦有需要，很容易将单机版的游戏改为网络版的（我现在就在做：））3.由于现在有很多手机都支持 J2ME ，而 J2ME 和 J2SE 是一脉相承的，因此，用 JAVA 编写的游戏可以很容易移植到 J2ME 平台上，想想当你的游戏在手机上运行是一样多么愉快的事情啊。
连连看游戏设计思想及程序详细讲解(附源码)
连连看游戏设计思想及程序详细讲解(附源码)１、连连的设计思想1)、准备好相应的大小相同的小图片若干public static final int CELL_SIZEx = 36;public static final int CELL_SIZEy = 40;public static final int CELL_COLS = 34;public static final int CELL_ROWS = 14;public static final int CELL_ZONGS = (CELL_COLS-2)*(CELL_ROWS-2);例如本程序：小图片宽：CELL_SIZEx = 36 高：CELL_SIZEy = 40摆放小图片舞台：横向：34格CELL_COLS= 34纵向：14格CELL_ROWS= 14真正要摆放图片的格数：CELL_ZONGS = (CELL_COLS-2)*(CELL_ROWS-2)即：四面的边格不放图片2)、设定34*14个图片数组，其中除四边外，全部随机存入图片，要保证每种图片各数相同（至少不要差太多），并且是偶数（奇数最后消不掉了）。
3)、在舞台上放上鼠标监听器，当点击任一图片时，做出判断，是否第一次点击（点击标记为0就是第一次点击），如果是第一次点击，就将相关信息记录到第一次内容中，比如：x1,y1,cell1,并将点击标记记为1，再次点击后，判断，点的是否同一图片，如果是，不做处理，如果不是，就认为点击了第二个图片，将相关住处记录到第二次内容中，如：x2,y2,cell2。
然后得用这个方法public boolean delkey()判断两点是否可以连通，如果可以，就消掉图片，不可以就不做处理。
整个连连看原理就是这样，其中有几个难点：１、随机图片，并且保证每种图片数相同，并且为偶数。
２、点击监听３、判断两点是否连通，这个算法是整个连连看的核心，也是最难的。
连连看游戏的设计与实现
连连看游戏的设计与实现摘要本文用VisualC++来设计与实现简单的连连看游戏的基本功能，玩家可以在游戏区域中通过键盘控制来选取相同的两个物件，采用特定的消除规则对它们进行消除的操作，当游戏区域中的所有方块对都被消除后玩家即可胜利。
本次课程设计对该游戏的算法以及游戏图案的绘制进行详细的介绍。
运用连线相消的方法完成了连连看游戏。
关键词：VisualC++6.0；连连看；游戏；3D绘图1引言1.1连连看游戏介绍游戏“连连看”顾名思义就是找出相关联的东西，它来源于街机游戏《四川麻将》和《中国龙》，是给一堆图案中的相同图案进行配对的简单游戏，在2003年，一个叫做朱俊的网友将这种形式搬到了PC上，立刻成为办公一族的新宠，并迅速传遍了世界各地。
饱受工作压力的人们没有太多的时间进行复杂的游戏，而对于这种动动鼠标就能过关的游戏情有独钟。
之后村子的连连看风靡版，阿达的连连看奥运版，连连看反恐版，还有敏敏连连看，水晶连连看等遍地开花，造就了一个连连看的新世界。
连连看游戏有多种地图样式和道具系统、大大加强了游戏的可玩性，是一款老少皆宜的休闲佳品。
1.2课程设计的目的网络小游戏制作的目的是满足了人们休闲的需要，在紧张工作之余休闲类的小游戏能够给人带来最大程度的放松，也可以增进人们之间的交流，沟通，通过游戏还可以认识更多的朋友，也可以到达跨省、跨市，甚至跨国间人们互相娱乐的目的。
另外也想通过本次课程设计将三年来所学的专业知识和其他方面的知识融入到实际应用中。
1.3主要问题开始制作游戏时，主要要解决的问题有以下几个方面：如何设置整个游戏的界面；如何控制连连看游戏中随机图片的生成且每种图片必须为偶数个；游戏开始后，判断鼠标两次点击的图片能否消去，即图片是否相同且图片之间路径的判断。
1.4课题实现技术的简要说明Visual C++是一个功能强大的可视化软件开发工具，Visual C++6.0不仅是一个C++编译器，而且是一个基于Windows操作系统的可视化集成开发环境（integrated development environment,IDE）。
数据结构试验-连连看
学生学号0121510870631实验课成绩学生实验报告书实验课程名称数据结构与算法综合实验开课学院计算机科学与技术学院指导教师姓名伍新华学生姓名蒋正琪学生专业班级物联网15022016-- 2017学年第 2 学期实验课程名称：数据结构与算法综合实验和原程序文件GameDlg.cpp。
第二组是实现消子功能的头文件CGameLogic.h和源程序文件CGameLogic.cpp。
第三组是实现游戏控制功能的头文件CGameControl.h和源文件CGameControl.cpp。
同时新建一个global.h文件来存放Vertex结构体来存放图片的相关信息。
二、调试说明（调试手段、过程及结果分析）调试内容为编写程序的语法的正确性与否，程序逻辑的正确性与否。
调试的主要手段是，设置断点，然后启动调试。
例如在编写GameDlg.cpp的时候出现了在游戏地图外出现虚影的问题，经过调试发现是游戏地图设置与进行游戏的界面大小设置不一致，经过修改终于解决。
同时，在编写程序时曾遇到图片不一致但是可以消子的状况，经过排查发现是程序的消子算法的x、y坐标弄反了，经过修改问题得以解决。
三、软件测试（测试效果.界面、综合分析和结论）1．测试效果.界面图1：主界面图2：基本模式界面图3：消子界面图4：重排界面图5：提示界面图6：判断胜负界面2．综合分析和结论通过对位图的存储和对位图进行随机抽取就能够出现如图片所示的界面，并且通过对图片的设置就能达到消子的效果。
能实验连连看实验的基本功能，绘制主界面地图，游戏界面地图，生成元素图片，元素图片的消除，连线的显示，计时，重排，提示等功能都能实现。
实验的目的基本达到，基本完成了一个连连看的游戏。
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 {/**连连看原始模型，供AS3交流所用*/import flash.display.Sprite;import flash.display.Loader;import .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 {//resetplarr.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 functionsprivate 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 functionspublic 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可以重排。
一款安卓手机游戏连连看的设计与实现
本科学生毕业设计Android 手机游戏连连看的设计与实现The Graduation Design for Bachelor's DegreeDesign and implementation of Android mobile phone gameHeilongjiang Institute of Technology2012-06·Harbin摘要随着3G 时代的到来，使得更多内容丰富的应用程序在手机上成为可能，为了承载更多的数据，以Google 公司发起的OHA 联盟走在了世界的前列，随着Android 手机平台的问世，给智能手机的发展带来了又一希望。
Android 凭借其开放性和灵活性渐渐赶超原有系统平台，成为近年来最热门的移动终端平台之一，在Android 平台上进行游戏的开发，成为一个有趣并富有潜力的领域。
本设计的目的就是为了了解和掌握Android 操作系统，并在Android 平台上做简单的移动智能应用开发。
平台采用Java 语言在Myeclipse 上实现并测试。
设计中首先对Android 平台的搭建作了简要的说明，然后介绍Android 平台上开发的小游戏“连连看”的过程及方法，该游戏实现了“连连看”游戏的基本功能，也列举出了在调试程序时遇到的一些问题和解决方法。
通过这次毕业设计，能使我们从软件的设计中体会到实际中软件开发的过程，提高我们的专业能力，从而学习到丰富的专业知识关键词：Android； Java； 3G；游戏ABSTRACTWith the arrival of the 3G era, more and more rich content of the application in the mobile phone to be possible. In order to carry more data, Google launched OHA union walk in the front of the world, with the advent of Android mobile phone platform, to the smart mobile phone development brought hope. Android by virtue of its openness and flexibility gradually surpass the original system platform, become the most popular mobile terminal platform in recent years, in Android platform to developing games, become an interesting and promising area.The purpose of this design is to understand and grasp the Android operating system. And in the Android platform to develop some simple mobile application, the platform using Java language to implementation and test in MyEclipse.The design of the first a brief description of the Android platform, the introduce the process and method of Android platform game ”Lianliankan”. The game is to achieve the basic functions of game, also enumerated that encountered some problems and solutions in debugging process. Through this graduation design , we can make the software design experience to the actual software development process, improve our professional ability, so as to learn professional knowledge.Keywords: Android；Java；3G；Game目录第一章概述------------------------------------错误！未定义书签。
Python连连看连接算法_322
Python 连连看连接算法_322Python 连连看连接算法[标签:作者][标签:来源][标签:时间]功能：为连连看游戏提供连接算法说明：模块中包含一个Point类，该类是游戏的基本单元“点”，该类包含属性：x,y,value。
其中x,y代表了该点的坐标，value代表该点的特征：0代表没有被填充，1-8代表被填充为游戏图案，9代表被填充为墙壁模块中还包含一个名为points的Point列表，其中保存着整个游戏界面中的每个点使用模块的时候应首先调用createPoints方法，初始化游戏界面中每个点，然后可通过points访问到每个点，继而初始化界面模块中核心的方法是link，通过提供源点和终点，可尝试连接两点，如果可以连接则返回保存路径的path列表，否则返回False复制代码代码如下:#-*-coding:utf-8-*-"""连连看连接算法为连连看游戏提供连接算法模块中包含一个Point类，该类是游戏的基本单元“点”，该类包含属性：x,y,value。
其中x,y代表了该点的坐标，value代表该点的特征：0代表没有被填充，1-8代表被填充为游戏图案，9代表被填充为墙壁模块中还包含一个名为points的Point列表，其中保存着整个游戏界面中的每个点使用模块的时候应首先调用createPoints方法，初始化游戏界面中每个点，然后可通过points访问到每个点，继而初始化界面模块中核心的方法是link，通过提供源点和终点，可尝试连接两点，如果可以连接则返回保存路径的path列表，否则返回False"""import random__author__ =";__license__ ="python"class Point:"""Point类Point类是游戏中基本单元：“点” """def __init__(self,x,y,value): self.x = xself.y = yself.value = valueself.directs = Noneself.changed = 0def __createDirect(self,pre,target): """构造点的方向集每个点在连接的过程中都持有一个方向集，这个方向集中保存着该点的前进方向选择的优先级优先级：指向目标点的方向级别最高，在同等级别并且遵循x方向优先于y方向"""self.directs = list()stx = target.x - self.xsty = target.y - self.yif stx >= 0 :self.directs.append("right") self.directs.append("left") else: self.directs.append("left") self.directs.append("right") if sty >= 0 :self.directs.insert(1,"up") self.directs.append("down") else:self.directs.insert(1,"down") self.directs.append("up") if pre == None :returnspx = pre.x - self.xspy = pre.y - self.yif spx == 0 :if spy == 1:self.directs.remove("up") else:self.directs.remove("down") else :if spx == 1:self.directs.remove("right") else:self.directs.remove("left") def forward(self,pre,target): """点的前进动作点的前进即是依次从方向集中取出优先级高的方向，并判断该方向上的下一个点是否被填充如果没有被填充则说明该方向可通，并返回该方向。
连连看游戏算法实现
连连看算法为了方便，我们假设棋盘大小为 4 * 4，棋子有 4 种。
数字化和布局算法首先，我们知道每种棋子有 4 个，我们可以先按顺序把每种棋子排好，然后再随机取其中两个棋子交换一下，多次交换后，棋子就是乱的了。
参考下面两图，图中用 4 种颜色表示 4 种棋子：(1)初始排布(2)多次随机交换两个棋子后实际上程序内部是不需要认识棋子的图象的，只需要用一个 ID 来表示，界面上画出来的棋子图形是根据 ID 取资源里的图片画的。
比如上图中用 4 种颜色表示 4 种棋子，我们可以定义红色棋子的 ID 为 0，绿色为 1，蓝色为 2，黄色为 3。
另外，如果棋子被消除 ID 可以定义为 -1。
把 ID 放在一个二维矩阵，画到界面上时，根据距阵里元素的位置和值(ID)决定在什么位置画什么颜色棋子。
我见过两种风格的连连看，有一种是和我写的水晶连连看一样，连线可以伸到棋子矩行外面，比如图(2)中的第一行有两个红色棋子，这两个是可以连的；另外一种和 QQGame 里的连连看一样，连线不能伸到棋子矩行外面，也就是说图(2)中的第一行的两个红色棋子是不能连的。
程序内部棋子都是数字，这两种风格的差别在于 ID 距阵的大小，第一种是：(行数 + 2) * (列数 + 2)；第二种是：行数 * 列数，这更简单，所以下面只说第一种。
(行数 + 2) * (列数 + 2) 的距阵，边界上都是 -1（也可以定义为别的，比如 -2），即留了空位给连线通过，而且这些空位不能安排任何棋子，在有些“关”的时候，棋子会移动，也不可以移动到边界的空位上！参考图(3)，其中灰色表示边界空位，灰色边界内部是棋盘：(3)棋盘矩阵化(4)棋子数字化连通算法（1）直连型：太简单不说了。
（2）一折型：其实相当于两个棋子划出一个矩形，这两个棋子是一对对角顶点，另外两个顶点如果可以同时和这两个棋子直连，那就说明可以“一折连通”。
见图(5)两个红色棋子的连通情况，右上角打叉的位置就是折点。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
[教程] 连连看核心算法详解最近做了个连连看游戏，综合网上各种不同的思路，整理出了个人认为大家都比较好理解的一套思路。
游戏规则：很简单,就是点中两个互相匹配并且可以通过不多于两个折点的折线连在一起的方块后,这两个方块就可以消掉。
(说明：下面的行和列按照现实的行和列,并不是按照flash坐标系的坐标，请大家按需转换)连通算法：1.直连型2.一折型3.两折型下面我们来分析每一种情况：直连型直连性又分为两种情况：横向直连，纵向直连。
首先是横向检测：a(1,2) , b(1,7)1.private function horizon(a:Point,b:Point):Boolean2.{3. if (a.x == b.x && a.y == b.y) return false; //如果点击的是同一个图案，直接返回false;4. var x_start:int = a.y < b.y?a.y:b.y; //获取a,b中较小的y值5. var x_end:int = a.y < b.y?b.y:a.y; //获取a,b中较大的值6. //遍历a,b之间是否通路，如果一个不是就返回false;7. for (var i:int = x_start + 1; i < x_end;i ++ )8. {9. if (mapData[a.x][i] != 0)10. {11. return false;12. }13. }14. return true;15.}16.其次是纵向检测：1.a(1,1) , b(4,1)2.3.private function vertical(a:Point,b:Point):Boolean4.{5. if (a.x == b.x && a.y == b.y) return false;6. var y_start:int = a.x < b.x?a.x:b.x;7. var y_end:int = a.x < b.x?b.x:a.x;8. for (var i:int = y_start + 1; i < y_end; i ++ )9. {10. if (mapData[i][a.y] != 0)11. {12. return false;13. }14. }15. return true;16.}一个拐角的检测如果一个拐角能连通的话，则必须存在C、D两点。
其中C点的横坐标和B相同，纵坐标与A相同，D的横坐标与A相同，纵坐标与B相同1.* a(4,2) , b(2,7)2.* c(2,2) , d(4,7)3.private function oneCorner(a:Point,b:Point):Boolean4.{5. var c:Point = new Point(b.x, a.y);6. var d:Point = new Point(a.x, b.y);7. //判断C点是否有元素8. if (mapData[c.x][c.y] == 0)9. {10. var path1:Boolean = horizon(b, c) && vertical(a, c);11. return path1;12. }13. //判断D点是否有元素14. if (mapData[d.x][d.y] == 0)15. {16. var path2:Boolean = horizon(a, d) && vertical(b, d);17. return path2;18. }else19. {20. return false;21. }22.23.}两个拐角的检测：这个比较复杂，如果两个拐角能连通的话，则必须存在图中所示的连线，这些连线夹在A、B的横、纵坐标之间,这样的线就以下这个类存储，direct是线的方向，用0、1表示不同的方向.Line类结构如下：1.package2.{3. import flash.display.Sprite;4. import flash.geom.Point;5.6. /**7. * ...8. * @author icekiller9. */10. public class Line extends Sprite11. {12. public var a:Point;13. public var b:Point;14. public var direct:int; //连线方向1:水平直连 0:垂直直连15. public function Line(a:Point,b:Point,direct:int)16. {17. this.a = a;18. this.b = b;19. this.direct = direct;20. }21.22. }23.24.}从A、B点的横纵两个方向进行扫描，就是Scan函数做的事情，把合适的线用LinkList存起来。
判断是否是二连型的算法需要做两个方向上的扫描：水平扫描和垂直扫描。
先看水平的，首先，要找到棋子往左右可以延伸的范围，这里的延伸是指左右有多少空的位置；然后，计算水平坐标上两个棋子延伸出来的公共部分；最后，找公共的水平坐标里有没有可以“垂直直连”的.用图6，7，8说明图(6)图(7)水平延伸图(8)求得水平延伸公共范围从图(8)可以看出，左边缘（第零列）有一对叉可以直连，所以红色棋子是可以“二折连通”的！1.2.private function scan(a:Point,b:Point):Vector.<Line>3.{4. linkList = new Vector.<Line>();5. //检测a点,b点的左侧是否能够垂直直连6. for (var i:int = a.y; i >= 0; i -- )7. {8. if (mapData[a.x][i] == 0 && mapData[b.x][i] == 0 && vertical(new Point(a.x,i),new Point(b.x,i)))9. {10. linkList.push(new Line(new Point(a.x,i),new Point(b.x,i),0));11. }12. }13. //检测a点,b点的右侧是否能够垂直直连14. for (i = a.y; i < col;i ++ )15. {16. if (mapData[a.x][i] == 0 && mapData[b.x][i] == 0 && vertical(new Point(a.x,i),new Point(b.x,i)))17. {18. linkList.push(new Line(new Point(a.x,i),new Point(b.x,i),0));19. }20. }21. //检测a点,b点的上侧是否能够水平直连22. for (var j:int = a.x; j >= 0; j -- )23. {24. if (mapData[j][a.y] == 0 && mapData[j][b.y] == 0 && horizon(new Point(j,a.y),new Point(j,b.y)))25. {26. linkList.push(new Line(new Point(j, a.y), new Point(j, b.y), 1));27. }28. }29. //检测a点,b点的下侧是否能够水平直连30. for (j = a.x; j < row; j ++ )31. {32. if (mapData[j][a.y] == 0 && mapData[j][b.y] == 0 && horizon(new Point(j,a.y),new Point(j,b.y)))33. {34. linkList.push(new Line(new Point(j, a.y), new Point(j, b.y), 1));35.36. }37. }38.39. return linkList;40.}取出LinkList里面的线，测试A与B到该线的两点是否连通1.2.private function twoCorner(a:Point,b:Point):Boolean3.{4. var ll:Vector.<Line> = scan(a, b);5. if (ll.length == 0)6. {7. return false;8. }9. for (var i:int = 0; i < ll.length; i ++ )10. {11. var tmpLine:Line = ll[i];12. if (tmpLine.direct == 1)13. {14.15. if (vertical(a,tmpLine.a) && vertical(b,tmpLine.b))16. {17. return true;18. }19. }else if (tmpLine.direct == 0)20. {21. if (horizon(a, tmpLine.a) && horizon(b, tmpLine.b))22. {23. return true;24. }25. }26. }27. return false;28.}前面的函数有以下这个总的调用函数来调用，传入两个点，就可以判断这两个点是否符合连连看的算法了：1.2.//总函数3.private function checkLink(a:Point,b:Point):Boolean4.{5.6. if (a.x == b.x && horizon(a, b))7. {8. return true;9. }10. if (a.y == b.y && vertical(a, b))11. {12. return true;13. }14. if (oneCorner(a, b))15. {16. return true;17. }18. else19. {20. return twoCorner(a, b);21. }22.}。