连连看核心算法

合集下载

《连连看分步实现》课件

《连连看分步实现》课件
连连看分步实现
汇报人:
目录
添加目录标题
连连看游戏简介
连连看游戏开发流 程
连连看游戏核心算 法
连连看游戏界面设 计
连连看游戏性能优 化
添加章节标题
连连看游戏简介
连连看游戏是一种流行的 休闲游戏,起源于中国
游戏玩法:通过连接两个 相同的图案来消除它们
游戏目标:在限定时间内 消除所有图案
游戏特点:简单易学,适 合各年龄段玩家
连连看游戏界面设 计
游戏背景:选择清新、舒适的 背景颜色和图案
游戏区域:设置合理的游戏区 域大小和位置
游戏元素:设计可爱的游戏元 素,如动物、水果等
操作按钮:设置清晰的操作按 钮,如开始、暂停、帮助等
设计原则:简洁、清晰、易于识别 颜色搭配:鲜艳、对比度高,易于区分 图标形状:圆形、方形、三角形等,易于识别和记忆 图标内容:动物、植物、食物、交通工具等,易于理解
游戏元素:卡通形象,色彩 鲜艳
游戏界面:简洁明了,易于 操作
游戏功能:得分、时间、提 示等
游戏音效:轻松愉快,增加 游戏趣味性
连连看游戏的基本规则 连连看游戏的数据结构 连连看游戏的搜索算法 连连看游戏的优化算法
功能测试:确保游戏功能正常,无 bug
用户体验测试:收集用户反馈,优 化游戏界面和操作流程
游戏特色:画面简 洁,操作简单,适 合各年龄段玩家
游戏逻辑设计:如何实现连连看的游戏规则和逻辑 图形界面设计:如何设计出美观、易用的图形界面 性能优化:如何优化游戏性能,提高运行速度 用户体验设计:如何设计出符合用户习惯的操作方式和界面布局
优化游戏界面:提高用户 体验,增加游戏趣味性
优化游戏规则:简化游戏 规则,提高游戏可玩性

连连看算法

连连看算法

连连看所要求的是:1:两个目标是相同的2:两个目标之间连接线的折点不超过两个。

(连接线由x轴和y轴的平行线组成)那么分析一下连接的情况可以看到,一般分三种情况1:直线相连2:一个折点3:两个折点如图:可以发现,如果有折点,每个折点必定有且至少有一个坐标(x或者y)是和其中一个目标点是相同的,也就是说,折点必定在两个目标点所在的x方向或y方向的直线上。

所以设计思路就是:假设目标点p1 , p2 ,如果有两个折点分别为z1 , z2 那么,所要进行的是1:如果验证p1 , p2 直线连线,则连接成立2:搜索以p1,p2的x,y方向四条直线(可能某两条直线会重合)上的有限点,每次取两点作为z1,z2 ,验证p1到z1/z1到z2/z2到p2 是否都能直线相连,是则连接成立。

(如果z1=z2也就是只有一个折点喽,对判断没影响)那么程序算法上,这里先就理论进行一个试验var mmap=new Array();mmap[0]=new Array(0,0,0,0,0,0);mmap[1]=new Array(0,1,2,8,1,0);mmap[2]=new Array(0,5,5,4,3,0);mmap[3]=new Array(0,4,6,7,3,0);mmap[4]=new Array(0,8,2,6,7,0);mmap[5]=new Array(0,0,0,0,0,0);p1=new Array(1,4);p2=new Array(1,2);//定义一个二维数组作为游戏的映像,相同的数字代表相同的图标,0是空处,p1,p2是选择的点linelink=function(o1,o2){var t=new Array(0,0);if(o1[0]==o2[0] || o1[1]==o2[1]){if(Math.abs(o1[0]-o2[0])+Math.abs(o1[1]-o2[1])<=1){return true;}else{t[0]=isNaN((o2[0]-o1[0])/Math.abs(o2[0]-o1[0])) ? o1[0] :o1[0]+((o2[0]-o1[0])/Math.abs(o2[0]-o1[0]));t[1]=isNaN((o2[1]-o1[1])/Math.abs(o2[1]-o1[1])) ? o1[1] :o1[1]+((o2[1]-o1[1])/Math.abs(o2[1]-o1[1]));return mmap[t[0]][t[1]]==0 ? linelink(t,o2) : false}}else{return false;}}// 上面这个函数是判断任意两个点是否能直线连接(中间的点全为0)var parr=new Array(); pickpoint=function(q1,q2){var j;parr.splice(0);for(j=0;j<mmap[q1[0]].length;j++){parr=mmap[q1[0]][j]==0?parr.concat([[q1[0],j]]):parr; }for(j=0;j<mmap[q2[0]].length;j++){parr=mmap[q2[0]][j]==0?parr.concat([[q2[0],j]]):parr; }for(j=0;j<mmap.length;j++){parr=mmap[j][q1[1]]==0?parr.concat([[j,q1[1]]]):parr; }for(j=0;j<mmap.length;j++){parr=mmap[j][q2[1]]==0?parr.concat([[j,q2[1]]]):parr; }}//上面这个函数是取出两个点的x和y直线方向上的所有空点保存进parr这个数组里面待搜索islink=function(p1,p2){var i,jif(p1==p2){return false;}if(mmap[p1[0]][p1[1]]<>mmap[p2[0]][p2[1]]){return false;}if(linelink(p1,p2)){return true;}else{for(i=0;i<parr.length;i++){for(j=0;j<parr.length;j++){if(linelink(p1,parr[i]) && linelink(p2,parr[j]) && linelink(parr[i],parr[j])) {trace(parr[i]+"->"+parr[j]);return true;}}} }return false;}//上面这个函数是校验两个目标点是否相连,//先判断是否同类点,再判断是否直线相连,最后搜索parr里的每对折点是否使目标点相连pickpoint(p1,p2); //取得parr数组trace(islink(p1,p2)); //测试p1,p2是否相连嘿,运行试试?这个是上面这几个函数的测试源码点击浏览该文件根据这个原理,把图标对照数组,动态建立数组,加上一些效果啊,鼠标检测啊,就成了下面这个这样的基本《连连看》游戏模块啦点击浏览该文件这个是作成游戏后的源码点击浏览该文件>>>> 进入论坛交流<<<<。

毕业设计基于JME的连连看游戏开发

毕业设计基于JME的连连看游戏开发

引言在如今3G时代,手机游戏、移动多媒体无线增值服务,已会成为一个热点。

我国主要的移动运营商正在积极努力致力于发展手机游戏业务。

在中国,手机游戏仍处于探索时期,其发展仍然受很多因素的制约。

面对广阔的市场和无限的潜在客户的基础上,如何真正让手机游戏在正确的轨道上发展和运作是电信运营商和游戏开发商急需解决的问题。

从用户角度看,手机游戏因其随时随地便于携带的基本特征备受用户关注。

因此用户无论在户外或车里,只要是空闲时间,都可以成为手机游戏参与者。

由于游戏节奏很快,不会占用用户大量的时间,游戏情节进度可以暂停等效果,给用户提供方便,并降低了游戏难度的阈值,提高用户的游戏的兴致度及可玩值,提供更适合的人在旅游时的休闲、娱乐功能。

从开发的角度上来看,成熟的手机游戏产品应该有以下几个方面:一个是能够适应庞大的用户群,即可以在高峰时间内集中加载游戏的信息;二是游戏可以适应不同的移动终端的屏幕尺寸;三是一个手机游戏的兼容性,一些智能手机的色彩和声音支持具有良好的兼容性;四是游戏中应当应用合理大小,若手机没有太大内存,用户下载和存储很难;五是游戏过程能中断性要求,结合不同的特点,可以实现手机操作系统的背景。

目前,手机网络游戏有两大发展的基本条件:一是有效的3G网络传输平台,在3G手机网络时代的传输速率和承载能力有了很大程度的提高,互联网电话打开网页时间基本控制在3秒左右,对移动电话使用3G网络的高速数据传输的实时转播的多媒体内容丰富,打破了数据传输速度的对手机游戏开发限制;二是完美的电话终端的软硬件支持环境,手机硬件生产、开发与手机操作系统的不断成熟,为移动终端平台实现多种插件凝聚力提供依据,手机的娱乐功能越来越易于实现高质量的,有利于各种手机网络游戏需要。

手机网络游戏市场的需求将在几年呈强劲的势头。

首先,是指在2002年左右发展迅速的PC网络游戏。

从中可以看到,中国的宽带互联网业务网络游戏和走进公众生活,占用庞大的用户群体,使中国的游戏厂商也如雨后春笋般迅速崛起一般。

连连看原理

连连看原理

用 JAVA 开发游戏连连看其实不管是做软件也好,做游戏也好,只要是写程序,在动手之前是一定会存在需求和分析的,如果不经过一定的分析就开始动手写程序,那么,这个程序一定会很难写下去的,最后的结果可能会导致放弃。

那么,在我们动手之前,让我们先简单的分析一下吧。

由于“连连看”并不是一个我们凭空开发的游戏,并且网上也已经有很多别人已经开发好的版本,因此,对于我们来说,我们已经拥有了一个很好的原型(比如说 QQ 游戏中的“连连看”),分析起来也应该是轻松得多。

由于 QQ 中的“连连看”是网络版,为了开发上的简便,我们先放弃网络功能,做一个简单的单机版就行了。

现在,让我们现在来看一看 QQ 中的连连看吧。

“连连看”的游戏规则其实并不复杂,首先,游戏开始的时候,地图上会有由数张不同的图片随机分散在地图上(并且每张图片会出现偶数次,通常是 4 次),只需要在地图上找出两张相同的图片(点),并且这两个点之前可以用不超过 3 条的直线连接起来就可以消除这两点,如此下去,直到地图上的点全部消除完就算游戏结束,怎么样,规则很简单吧?:)我们的开发就完全按照些规则来吧。

分析游戏规则找出算法通过上面的分析,我们已经知道了游戏规则,可是,我们怎么样去实现呢?其实所谓的实现也就是算法,那我们怎么样找出算法呢?别急,让我们来看一看上图,或者自己动手玩一玩别人做好的。

通过对上图的观察,我们发现,可以将游戏中的地图看作是一个二维数组,其中的所有图片(以下称“点”)可以看作是数组中的一个具体的元素。

那么,游戏中相同的图片可以看作是数组中不同位置两个值相同的元素。

至于直线,让我们给组数中的每一个元素赋一个特殊的值如 0 ,以表示地图上空白的位置。

并且同时规定:当连续的具有该特殊值的点的横向索引或纵向索引相同时,可以认为这是一条直线,比如下图:当数组中两点的值相同并且两点间只需要不超过 3 根直线能连接起来的时候,就让这两点的值变为 0 ,如果数组中全是 0 值的点,就认为游戏已经结束:)怎么样,算法够简单了吧:)用伪代码来描述程序的结构现在,我们用伪代码来描述一下游戏,假设用户开始了游戏:消除两点;上次选择的点 = null ;if ( 地图上已没有可消除的点 ) { 游戏结束;}}else {上次选择的点 = 当前点;}}else {上次选择的点 = 当前点;}}游戏结束;看看有没有什么问题?如果没有问题,我们进入下一步吧:)确定程序需要的模块当伪代码完成后,并且在我们的大脑里转了几圈发现没有问题后,现在就可以开始进行模块的划分工作了。

连连看的算法

连连看的算法

0, 0, 0, 0, 0, 0, 0, 0 , 0, 00, 8, 0, 0, 0, 0, 0, 0 , 0, 00, 0, 0, 0, 0, 0, 0, 0 , 0, 00, 0, 0, 0, 0, 0, 0, 0 , 0, 00, 0, 0, 0, 0, 0, 0, 0 , 0, 00, 0, 0, 0, 0, 0, 0, 0 , 0, 00, 0, 0, 0, 0, 0, 0, 0 , 0, 00, 0, 0, 0, 0, 0, 0, 0 , 9, 00, 0, 0, 0, 0, 0, 0, 0 , 0, 0这是一张连连看的地图,假设标8和9的部分是两张相同的牌。

在数组矩阵中,0表示没有牌,大于1表示有牌。

至于是什么牌,那是随机的了。

不要告诉我,你说的“布局算法”是指怎么把牌刚刚好放上去,那个无所谓什么算法,你只要首先在地图数组中准备好偶数个1,在布牌时保证每种牌是偶数个(不同种类的牌用大于1的数来表示),相应地放入每个1的位置上就可以了。

一、计算地图上这两张牌能不能连通(当然能了,哈哈)。

这是连连看寻路算法的第一步。

先定义一下两张牌能连的充分条件:1.两张牌是同一种。

2.两张牌之间有一条全是0的路可以连通。

3.这一条路不能有两个以上的拐角(corner)满足这三个条件,就可以认为这两张牌是可以连的。

首先,我们依据前两个条件来完成一个基本的寻路算法。

我们的目的是从8到9找出一条可以连通的路来。

那么很明显从8到9的第一步一其有四个方向可以选择,分别是东,南,西,北(e, s, w, n以中国地图方向为标准)四个方向,在第一步中我们首先假设四个方面没有任何优劣,那么我可以任意选择一个方向移动,那就是东面吧。

图二:0, 0, 0, 0, 0, 0, 0, 0 , 0, 00, 8, -8, 0, 0, 0, 0, 0 , 0, 00, 0, 0, 0, 0, 0, 0, 0 , 0, 00, 0, 0, 0, 0, 0, 0, 0 , 0, 00, 0, 0, 0, 0, 0, 0, 0 , 0, 00, 0, 0, 0, 0, 0, 0, 0 , 0, 00, 0, 0, 0, 0, 0, 0, 0 , 0, 00, 0, 0, 0, 0, 0, 0, 0 , 9, 00, 0, 0, 0, 0, 0, 0, 0 , 0, 0我从8向东移动了一步,所以到达了-8的位置,我之所以可以移到-8位置,很明显,是因为-8的位置上原来是一个0,表示没有牌阻挡。

连连看算法详谈

连连看算法详谈

游戏连连看的算法探究及源码实现(1)------ 综述述---转载时请注明原文出处(/wyw1976)及作者邮箱(wyw1976@)“连连看”是一款老少皆宜、百玩不厌的休闲类小游戏。

各种“连连看”也层出不穷、五花八门,例如“果蔬连连看”、“宠物连连看”、“麻将连连看”等。

各种“连连看”大同小异,无非就是界面图片不同,其核心算法应该是类似的。

闲暇时,自己也编了一个“连连看”小游戏,大约有1000行代码,功能如下:(1)纯C、纯字符界面,下面是截图:(2)10种游戏模式:∙普通模式∙左移模式∙右移模式∙上移模式下移模式∙左右分离模式∙上下分离模式∙水平中线聚集模式∙垂直中线聚集模式中心点聚集(3)随机产生游戏初始布局。

(4)随时进行“死锁”监控(5)“死锁”发生时,重新生成游戏残局(6)“路径输出”。

在连通时,输出连通路径。

(7)支持“自动”和“手动”两种模式。

在“自动”模式中,计算机模拟用户完成整个游戏。

这在算法测试时显得尤为重要,因为靠人工来完成算法的测试,十分低效甚至不可能全覆盖,而“自动”模式中,计算机完成一局的时间只要几秒,很容易发现算法中的漏洞。

(8)支持性能统计。

这对于算法优化很重要。

游戏"连连看"的算法探究及源码实现(2)----- 流程图下面是“连连看”的流程图:说明:(1)在"死锁"判定时,只要找到了一对匹配的点,就立即退出并记录该匹配点对,(在需要提示的时候,只要输出该点对即可)。

(2)如果用户的输入点对是连通的,而且与匹配点对中的任何一个是相同的,则需要重新进行“死锁”判定。

(3)在“连通”判定过程中,会生成连通路径。

(4)“更新游戏布局”包括移动相关的点,及消除匹配点。

(5)“初始布局”和“残局”的处理是不同的,这点我们还会详细说明(6)从上述流程图中,可以看出程序主要包含以下几个模块:∙随机生成游戏初始布局∙“死锁”判定∙随机产生游戏残局∙连通判定∙游戏布局更新∙生成联通路径我们将详细描述以上模块的算法及其实现。

《连连看》算法c语言演示(自动连连看)

《连连看》算法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两点。

连连看算法及实现原理详解(C++源码)

连连看算法及实现原理详解(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);//图案总的个数

最新Android连连看课程设计

最新Android连连看课程设计

A n d r o i d连连看课程设计«Skip Record If...»滨江学院Android课程设计题目连连看院系计算机系专业网络工程学生姓名吴培培学号 20112346060二O一四年六月一日Android连连看课程设计吴培培一.概论1.1 Android简介Android是一种基于Linux的自由及开放源代码的操作系统,主要使用于移动设备,如智能手机和平板电脑,由Google公司和开放手机联盟领导及开发。

Android操作系统最初由Andy Rubin开发,主要支持手机。

2007年11月,Google与84家硬件制造商、软件开发商及电信营运商组建开放手机联盟共同研发改良Android系统。

随后Google以Apache开源许可证的授权方式,发布了Android的源代码。

第一部Android智能手机发布于2008年10月。

Android逐渐扩展到平板电脑及其他领域上,如电视、数码相机、游戏机等。

2011年第一季度,Android在全球的市场份额首次超过塞班系统,跃居全球第一。

2013年的第四季度,Android平台手机的全球市场份额已经达到78.1%。

2013年09月24日谷歌开发的操作系统Android迎来了5岁生日,全世界采用这款系统的设备数量已经达到10亿台。

2014第一季度Android平台已占所有移动广告流量来源的42.8%,首度超越iOS。

但运营收入不及iOS。

Android一词的本义指“机器人”,同时也是Google于2007年11月5日宣布的基于Linux平台的开源手机操作系统的名称,该平台由操作系统、中间件、用户界面和应用软件组成。

Android一词最早出现于法国作家利尔亚当(Auguste Villiers de l'Isle-Adam)在1886年发表的科幻小说《未来夏娃》(L'ève future)中。

他将外表像人的机器起名为Android。

AS3连连看核心算法详解

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两点。

游戏程序设计(2)--“连连看”设计

游戏程序设计(2)--“连连看”设计

2、 按钮事件 、
ActionListener接口: 接口: 接口 (1)注册监听器 ) 按钮.addActionListener(this); 按钮 (2)触发事件 ) actionPerformed(ActionEvent e) { …….. }
3、 产生随机数 、
随机函数: 随机函数: Math.random() 产生0-1之间的随机数 产生 之间的随机数 若要产生100以内的随机整数: 以内的随机整数: 若要产生 以内的随机整数
• 2、“连连看”游戏的几种可以消去情况 • (1)要消去的两个图案相邻,如图15.2(a)所示。 • (2)要消去的两个图案在同一直线上,如图 15.2(b)所示。 • (3)要消去的两个图案不在同一直线上,如图 15.2(c)、(d)所示。
3、“连连看”游戏连接算法思 、 连连看” 路 • 1、什么是连接折点?如图15.3所示 、什么是连接折点?
• 2、建立一个8×7的二维数组存放 ×5个随机数 、建立一个 × 的二维数组存放 的二维数组存放6× 个随机数
• int d[ ][ ] = { • {0, 0, 0, 0, 0, 0, 0}, • {0, 0, 0, 0, 0, 0, 0}, • {0, 0, 0, 0, 0, 0, 0}, • {0, 0, 0, 0, 0, 0, 0}, • {0, 0, 0, 0, 0, 0, 0}, • {0, 0, 0, 0, 0, 0, 0}, • {0, 0, 0, 0, 0, 0, 0}, • {0, 0, 0, 0, 0, 0, 0} };
• 2、连接折点算法基本概念 如图15.3所示 、 • 3、连接折点算法分析 、
• (1)判断选取的两个点(P1, P2)的内容是否一样。 • (2)判断P1、P2的位置关系。 • (3)如果P1、P2相邻,如图15.4(a)所示,直接消去该两点,即把 这两点的内容消去(把该两点内容设为不可见)。 • (4)如果P1、P2 在同一直线上,但不相邻,如图15.4(b)所示。 先判断两个点P1,P2之间是否能直接建立连接(连线之间无折点), 如果可以的话消去该两点,如果不可以的话就在其它三个方向上的空 点按照折点法基本概念开始取折点Z1, Z2, 然后判断 P1 — Z1, Z1—Z2,Z2—P2 是否能连通,如果都可以连通就消去P1, P2两点。 要消去的两个点不在同一直线上也不相邻。 • (5)在P1, P2四个方向上的空点按照连接折点的基本概念开始取 折点Z1, Z2, 然后判断 P1—Z1,Z1—Z2,Z2—P2 是否能连通, 如果都可以连通就消去P1, P2两点。如图15.3所示。

连连看原理

连连看原理

用 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、连连的设计思想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()判断两点是否可以连通,如果可以,就消掉图片,不可以就不做处理。

整个连连看原理就是这样,其中有几个难点:1、随机图片,并且保证每种图片数相同,并且为偶数。

2、点击监听3、判断两点是否连通,这个算法是整个连连看的核心,也是最难的。

连连看游戏算法

连连看游戏算法

• 注意::这里很容易忽略的一个情况就是 两个方块相邻.这时,y1与y2之间没有点.如 果不检验就会错误地跳到二级检验里去.为 了避免这种状况的出现,可以在循环之前,定 义一临时变量temp=true,然后才到循环语 句,遇到障碍物就让temp=false,并且跳出 循环.这时,对于相邻的情况来说,因为循环 次数为0,所以temp绝对为true. • 综上所述,temp=true,checkNoBarrier就 返回true,否则要进入二级检验.
• 我们来采用逐级算法:先看能否直线连接, 若不行,再拐一个弯,再不行,继续拐弯.这也 符合一些游戏者玩游戏时判断连接的方法. • 这里,把检验连接是否成功定义为一个函数 checkNoBarrier(x1,y1,x2,y2),true表 示连接成功,false表示连接失败.所以,返回 true一般比返回false快.因为只要有一根折 线连上了,就可以退出函数.而false则要所 有尝试都失败了才能返回
连连看游戏算法
连连看游戏规则很简单,就是点中两 个互相匹配并且可以通过不多于两个 折点的折线连在一起的方块后,这两 个方块就可以消掉.
下图的三种情况可以把方块消掉.我们可以 假设,配对规则是两数相加等于100.
说明:配对的检查比较简单,只要用一个if 语句,条件a+b==100就可以检验了.而两 方块能否实现折线连接,则是个相对复杂的 问题.
• 如果都没有一个返回true的话,或者根本找 不到可以作一级检验的点对(特别是当某个 方块被障碍物紧紧包围的时候),那么三级检 验结果为false,此时,折线的折点数已经达 到2,根据游戏规则,此时checkNoBarrier 返回false了.
•至此逐级算法结束
两点注意的问题:

连连看消除算法

连连看消除算法

连连看消除算法说明:本算法为个人意愿,意在实现功能,并非最优,便于大家理解连连看游戏的实质。

游戏规则:连连看游戏的消除规则玩过了应该挺容易理解,就是两点之间只能用水平或者竖直线段连接,最多不能超过2个拐点。

所以分成了4种情况,1、 直接相连2、 转一次弯相连3、 Z 型相连4、 U 型相连下面开始提出一种直观的算法:我们来判断两个物体能否消除。

1、 我们从一个物体出发,沿十字向外搜集直接相连点,遇到其他物体就终止当前方向搜索。

对两个待判断的物体都进行十字点收集。

2、 我们定义一下直接相连:两个点处于水平或者竖直位置,并且中间没有任何其他物体阻挡。

A 、如果是处于消除情况1(直接相连)的情况,那么第二个点应该在第一个的十字搜集点上(直接连)B 、如果是处于消除情况2(转一次弯)的情况,那么物体1十字线上的某点肯定能够和2直接相连C、如果是处于消除情况3或者4,那么物体1十字线上的某点肯定能够和物体2十字线上的某点直接相连D、边界问题我们单独考虑,有的游戏规则中可以边界外走线,有的则不可以,这个对我们算法没有影响。

所以整个程序实现就简单了,伪代码:函数A,判断两点是否可以直接消除函数B,收集指定点十字方向全部直接相连点如果两点可直连则可消除遍历2的直连点如果点1和点2十字中某点可直连则可消除遍历1,2的直连点如果有可直连点则可消除给出一个没完成的python代码供参考:'''Description:link link game auto solver algorithm.Author:winxosDate:2011-05-18'''import randomsize=10m=[[0 for x in range(size)] for y in range(size)]defcreatemap():defcreatepos():return [random.randint(0, size-1), random.randint(0, size-1)]deffillpair(n):a=createpos()while m[a[0]][a[1]]!=0:a=createpos()b=createpos()while m[b[0]][b[1]]!=0 or b==a:b=createpos()m[a[0]][a[1]]=nm[b[0]][b[1]]=nfor i in range(20):fillpair(random.randint(1, 9))passdefisdirectlink(a, b):#a,b is point#return 1 means can link directlyif a[0]==b[0] and a[1]==b[1]: #same point return false return 0if a[0]==b[0]: #Verticalif a[0]==0 or a[0]==size-1: #bound is linkablereturn 1sa=a[1]sb=b[1]ifsb<sa: #field from sa to sb, sa<sbsa=b[1]sb=a[1]for i in range(sa+1, sb-1):if m[a[0]][i]!=0:return 0return 1if a[1]==b[1]: #Horizonif a[1]==0 or a[1]==size-1: #bound is linkablereturn 1sa=a[0]sb=b[0]ifsb<sa: #field from sa to sb, sa<sbsa=b[0]sb=a[0]for i in range(sa+1, sb-1):if m[i][a[1]]!=0:return 0return 1passreturn 0defonelinepoint(a): #return the cross directly linkable points.r=[]i=a[0]-1while m[i][a[1]]==0 and i>0:r.append([i, a[1]])i-=1i=a[0]+1while m[i][a[1]]==0 and i<size:r.append([i, a[1]])i+=1j=a[1]-1while m[a[0]][j]==0 and j>0:r.append([a[0], j])j-=1j=a[1]+1while m[a[0]][j]==0 and j<size:r.append([a[0], j])j+=1return rdefislinkable(a, b): #core function ifisdirectlink(a, b):return 1sa=onelinepoint(a)sb=onelinepoint(b)for x in sa:ifisdirectlink(x, b):return 2for x in sb:ifisdirectlink(a, x):return 2for x in sa:for y in sb:ifisdirectlink(x, y):return 3return 0defprt(n):print("---begin---")for x in n:print(x)createmap()a=[5, 5]b=onelinepoint(a)prt(m)print(b)print("done!")。

Python连连看连接算法_322

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): """点的前进动作点的前进即是依次从方向集中取出优先级高的方向,并判断该方向上的下一个点是否被填充如果没有被填充则说明该方向可通,并返回该方向。

连连看游戏设计报告

连连看游戏设计报告

武汉工程大学计算机科学与工程学院综合设计报告设计名称:系统软件综合设计设计题目:手机连连看游戏设计与实现学生学号:1005090222专业班级:2010级计算机科学与技术(计算机科学方向)02班学生姓名:杨星学生成绩:指导教师(职称):徐银霞(讲师)课题工作时间:2013.12.30 至2014.1.10成绩评定表学生姓名:杨星学号:1005090222 班级:计算机科学02班答辩记录表指导教师评语目录摘要 (II)Abstract (III)第一章课题背景 (1)1.1 课题背景 (1)1.2 设计要求 (1)第二章设计方案论述 (3)2.1 需求分析 (3)2.2 模块设计 (3)第三章详细设计 (5)3.1 开发环境 (5)3.2 算法描述 (5)3.3 类的设计 (7)第四章设计结果及分析 (9)4.1 游戏启动测试 (9)4.2 游戏过程测试 (9)4.3 游戏结束测试 (10)总结 (12)致谢 (13)参考文献 (14)附录主要程序代码 (15)摘要连连看是一款经典的休闲游戏,将相同的两个图案以三根以内的线连接起来即可消除,规则简单易上手,游戏节奏快,不失乐趣,适合广大人群。

这里设计的连连看游戏实现在windows phone 8手机平台上。

旨在熟悉其基本的开发模式,了解手机平台应用开发与PC平台的不同之处,感受移动平台独特的特性。

作为手机游戏,操作直观,随时随地可进行游戏,更加方便快捷。

游戏实现计时,提示,重新开始等基本功能。

游戏核心算法为计算两个相同图案之间的最短路径。

分图案相邻和不相邻情况。

对于相邻图案直接可消除,对于不相邻图案,通过特定算法求解,寻求最短路径。

失败则无法消除。

游戏基于.NET平台,以Visual Studio Express For Windows Phone工具开发,采用Silverlight框架,用C#程序设计语言设计。

经测试可运行在windows phone 8手机上。

C++实现连连看游戏核心代码

C++实现连连看游戏核心代码

C++实现连连看游戏核⼼代码这两天研究了⼀下连连看游戏的源代码,感觉它挺简单的,主要就是判断选中的两张图⽚能否消去。

我参考了⽹上的源代码(抱歉的是,不记得当时下载的⽹址了,在此对原作者表⽰深深的歉意!),然后⾃⼰把核⼼代码整理如下,与⼤家共享。

需要说明的是,这只是核⼼算法的代码,界⾯设计和操作的代码均已略去。

#include <stdlib.h>#include <time.h>//图⽚类class picture{public:int type;//图⽚的编号,共有n种,从0到n-1bool visible;//图⽚是否可见int x;//图⽚位置的横坐标int y;//图⽚位置的综坐标};//整个图由8⾏10列组成,每个单元格是⼀张⼩图⽚const int pNum = 10;const int pType = 8;static picture p[pType][pNum];//进⼊新⼀关void newStage(){srand(time(0));int i,j;for(i = 0;i < pType;++i)for(j = 0;j < pNum;j++)p[i][j].visible = false;int x,y;for (i = 0;i < pType - 1;++i)for(j = 0;j < pNum;++j){bool re = true;while (re){x = rand() % pType;y = rand() % pNum;if (p[x][y].visible == false){p[x][y].type = i;p[x][y].visible = true;p[x][y].x = x;p[x][y].y = y;re = false;}}}//处理剩余的最后⼀种图⽚for (i = 0;i < pType;++i)for(j = 0;j < pNum;++j){if (p[i][j].visible == false){p[i][j].type = pType - 1;p[i][j].visible = true;p[i][j].x = i;p[i][j].y = j;}}}//在a、b两点之间画线void drawLine(picture a,picture b){}//判断图⽚a和b之间能否通过⼀条直线相连(a和b之间有0个转⾓)bool matchDirect(picture a,picture b){if(!(a.x == b.x || a.y == b.y))return false;//a、b的横坐标相同时bool yMatch = true;if(a.x == b.x){if(a.y > b.y){for(int i = b.y + 1;i < a.y;++i){if(p[a.x][i].visible == true)yMatch = false;}}if(b.y > a.y){for(int i = a.y + 1;i < b.y;++i){if(p[a.x][i].visible == true)yMatch = false;}}}//a、b的纵坐标相同时bool xMatch = true;if(a.y == b.y){if(a.x > b.x){for(int i = b.x + 1;i < a.x;++i){if(p[i][a.y].visible == true)xMatch = false;}}if(b.x > a.x){for(int i = a.x + 1;i < b.x;++i){if(p[i][a.y].visible == true)xMatch = false;}}}return (xMatch && yMatch);}//判断图⽚a和b之间是否可以通过⼀个转⾓的折线相连bool matchOneCorner(picture a,picture b){if (p[a.x][b.y].visible == false && matchDirect(a,p[a.x][b.y]) && matchDirect(p[a.x][b.y],b)) {drawLine(a,p[a.x][b.y]);drawLine(p[a.x][b.y],b);return true;}if (p[b.x][a.y].visible == false && matchDirect(a,p[b.x][a.y]) && matchDirect(p[b.x][a.y],b)) {drawLine(a,p[b.x][a.y]);drawLine(p[b.x][a.y],b);return true;}return false;}//判断图⽚a和b之间是否可以通过两个转⾓的折线相连bool matchTwoCorner(picture a,picture b){int i,j;for(i = a.x - 1,j = a.y;i >= 0;--i){if(p[i][j].visible == true)break;else if(matchOneCorner(b,p[i][j])){drawLine(a,p[i][j]);return true;}}for (i = a.x + 1,j = a.y;i < pNum;++i){if(p[i][j].visible == true)break;else if(matchOneCorner(b,p[i][j])){drawLine(a,p[i][j]);return true;}}for(i = a.x,j = a.y - 1;j >= 0;--j){if(p[i][j].visible == true)break;else if(matchOneCorner(b,p[i][j])){drawLine(a,p[i][j]);return true;}}for(i = b.x,j = b.y + 1;j < pType;++j){if(p[i][j].visible == true)break;else if(matchOneCorner(b,p[i][j])){drawLine(a,p[i][j]);return true;}}return false;}//判断a和b能否相连,条件是a和b的类型相同,且a和b之间的连线拐⾓数<=2个bool match(picture a,picture b){if(a.type != b.type)return false;if(matchDirect(a,b)){drawLine(a,b);return true;}else if(matchOneCorner(a,b))return true;else if(matchTwoCorner(a,b))return true;return false;}关于C++⼩游戏的更多精彩内容请点击专题:学习了解以上就是本⽂的全部内容,希望对⼤家的学习有所帮助,也希望⼤家多多⽀持。

说说连连看游戏的算法设计——生成地图篇

说说连连看游戏的算法设计——生成地图篇

说说连连看游戏的算法设计——生成地图篇最近突发奇想,想写一个连连看小游戏玩一下。

没动手的时候以为这个游戏简单的不得了,写起来应该是一挥而就的感觉;等真的写起来才发现是纸上谈来终觉浅,绝知此事要躬行啊。

连连看的核心算法主要由两部分组成,第一个是地图的生成算法,另一个是地图寻路的算法。

本文主要讨论地图的生成。

我们设地图是一个m x n二维数组。

生成算法:生成算法要求生成一个不总有连续标记出现的二维数组,数组中每个元素都要出现偶数次。

分析:这个数组必须要有偶数个元素:所以m*n%2==0;其他就是考虑出现偶数次数据和乱序排列的问题了。

现在我们设m=6,n=6进行讨论。

并设现在数组中共有6个元素可供选择,不要求所有元素都出现,但如果出现必须出现偶数次。

方法一:先生成一个顺序排列的二位数组如:1map[m][n]={{1,2,3,4,5,6},2{1,2,3,4,5,6},3{1,2,3,4,5,6},4{1,2,3,4,5,6},5{1,2,3,4,5,6},6{1,2,3,4,5,6},}然后循环遍历数组元素和数组中任意位置的数交换,得到打乱顺序的数组。

7map[m][n]={{1,4,2,5,6,2,}8{2,1,6,5,1,2,}9{1,2,3,5,3,4,}10{1,4,3,6,6,6,}11{4,6,3,5,3,5,}12{4,2,5,1,4,3,}}评价:此方法生成初始数组的过程简单,但是初识变量需要人为规定好如何布局,以确保有偶数个元素出现,并且每个元素出现的次数固定,对元素个数也有一定要求。

随机打乱后数组元素的离散度不高。

方法二:1、根据数组可用元素个数x,先生成二维数组的前m*n-x个元素。

这些元素的值随机取任意有效值(可让每个元素与前方,上方元素不等)。

2、另开辟一长度x的一维数组a[x]记录每个有效值出现的次数。

3、根据a将出现奇数次的元素排列于二维数组末尾,其余位置用随机一对儿相投元素填充。

连连看项目设计

连连看项目设计

武汉工程大学计算机科学与工程学院项目报告设计名称:《Windows程序设计》综合项目设计题目:连连看游戏项目开发学生学号:1005110129专业班级:二〇一〇级信息技术01班学生姓名:周敏学生成绩:指导教师(职称):张俊(副教授)课题工作时间:2012年4月说明:1、报告中的第一、二、三项由指导教师在综合设计开始前填写并发给每个学生;四、五两项(中英文摘要)由学生在完成综合设计后填写。

2、学生成绩由指导教师根据学生的设计情况给出各项分值及总评成绩。

3、指导教师评语一栏由指导教师就学生在整个设计期间的平时表现、设计完成情况、报告的质量及答辩情况,给出客观、全面的评价。

4、所有学生必须参加综合设计的答辩环节,凡不参加答辩者,其成绩一律按不及格处理。

答辩小组成员应由2人及以上教师组成。

5、报告正文字数一般应不少于5000字,也可由指导教师根据本门综合设计的情况另行规定。

6、此表格式为武汉工程大学计算机科学与工程学院提供的基本格式(适用于学院各类综合设计),各教研室可根据本门综合设计的特点及内容做适当的调整,并上报学院批准。

成绩评定表答辩记录表目录摘要 (Ⅲ)Abstract (Ⅳ)第一章课题背景(或绪论、概述) (1)1.1 设计背景和目的 (1)1.1.1 设计背景 (1)1.1.2 目的和意义 (1)1.2 主要问题和技术要求 (1)1.2.1 应解决的主要问题 (1)1.2.2 应达到的技术要求 (2)1.3 理论依据和主要工作内容 (2)1.3.1 基本理论依据 (2)1.3.2 主要工作内容 (2)第二章设计简介及设计方案论述 (3)2.1 设计简介 (3)2.1.1游戏具有功能 (3)2.1.2 类的定义 (3)2.1.3 成员函数 (4)2.2 设计方案论述 (5)2.3 设计图 (6)第三章详细设计 (7)3.1 界面设计 (7)3.2 主要功能模块 (7)3.2.1 时间限制模块 (7)3.2.2 消除棋子模块 (9)3.2.3 游戏升级模块 (11)3.2.4 提示消除模块 (11)3.2.5 棋子换盘模块 (12)3.2.6 英雄榜、音乐播放、帮助类模板 (13)第四章功能测试 (15)4.1 进入主界面 (15)4.2 帮助 (16)4.3 游戏 (16)4.3.1 开始游戏 (16)4.3.2 消除棋子 (17)4.3.3 换盘 (18)4.3.4 游戏升级 (19)4.4 英雄榜 (20)总结 (21)致谢 (22)参考文献 (23)附录主要程序代码………...………………………………..摘要为了丰富大众生活,在学习工作之余可以放松心情,设计了《连连看》的相关项目。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

连连看核心算法转:最近参考一个JAVA的版本写了一个AS3版的连连看游戏算法, 欢迎大家拍砖指正,里面用到了as3ds类库, 还有一些粉简单的辅助类就不贴出来了, 各位闭着眼睛也能想象出来, 看主要的逻辑吧:package ponents{import de.polygonal.ds.Array2;import de.polygonal.ds.DLinkedList;import de.polygonal.ds.Iterator;import flash.geom.Point;import utils.*;/*** 连连看算法* @author Luan (verycss-ok@)*/public class Map{private var _level:uint; //游戏关卡对应的项目数量private var _map:Array2; //二维数组private var _array:Array; //辅助的一维数组private var _restBlock:uint = 0; //剩余的项目数量private var _vector:DLinkedList; //保存符合条件线段的地方private var _countOfPerItem:uint; //每个项目出现的次数(偶数)private var _result:MatchResult; //暂存符合条件的结果public function Map(level:uint = 16){//加2是为了加一圈0_map = new Array2( Setting.COLUMN+2, Setting.ROW+2 );_array = new Array(_map.size - 2*_map.width - 2*_map.height + 4);_vector = null;_result = new MatchResult();//调用setterthis.level = level;}/********************** getter & setter **********************/public function set level(value:uint):void{_level = value;//取得一个尽量大的偶数值_countOfPerItem = NumberUtil.getFloorEven(_map.size / _level);_restBlock = _level * _countOfPerItem;_initMap();}public function get count():uint{return _restBlock <= 0?0:_restBlock;}public function get map():Array2{return _map;}public function get result():MatchResult{return _result;}/********************** 私有方法**********************/private function _initMap():void{//一维数组初始化和乱序for (var n:uint = 0; n < _array.length; n++)_array[n] = 0;for (var i:uint = 0; i < _level; i++){for (var j:uint = 0; j < _countOfPerItem; j++){_array[i * _countOfPerItem + j] = i + 1;}}_array = ArrayUtil.random(_array);ArrayUtil.drawWrappedMap(_array, _map);}/*** 横向检查* @param a* @param b* @return*/private function _hTest(a:Point, b:Point):MatchResult {if (a.x == b.x || a.y != b.y ) return null;var x_start:uint = Math.min(a.x, b.x);var x_end:uint = Math.max(a.x, b.x);for (var x:uint = x_start + 1; x < x_end; x++)if ( _map.get(x, a.y) != 0 )return null;return _result.fill(a.clone(), b.clone());}/*** 纵向检查* @param a* @param b* @return*/private function _vTest(a:Point, b:Point):MatchResult {if (a.y == b.y || a.x != b.x) return null;var y_start:uint = Math.min(a.y, b.y);var y_end:uint = Math.max(a.y, b.y);for (var y:uint = y_start + 1; y < y_end; y++)if ( _map.get(a.x, y) != 0 )return null;return _result.fill(a.clone(), b.clone());}/*** A 、B 之间有一个拐点* @param a* @param b* @return*/private function _oneCorner(a:Point, b:Point):MatchResult {var c:Point = new Point(a.x, b.y);var d:Point = new Point(b.x, a.y);var isMatch:Boolean = false;if (_map.get(c.x, c.y) == 0) //C 点上必须没有障碍{isMatch = _vTest(a, c) && _hTest(b, c);if (isMatch){_result.clear();return _result.fill(a.clone(), b.clone(), c.clone());}}if (_map.get(d.x, d.y) == 0) //D 点上必须没有障碍{isMatch = _hTest(a, d) && _vTest(b, d);if (isMatch){_result.clear();return _result.fill(a.clone(), b.clone(), d.clone());}}return null;}/*** 扫描两点决定的矩形范围内有没有完整的空白线段* @param a* @param b* @return*/private function _scanLine(a:Point, b:Point):DLinkedList {var v:DLinkedList = new DLinkedList();// 从a, c 连线向b 扫描,扫描竖线// 扫描A 点左边的所有线for (var x1:Number = a.x; x1 >= 0; x1--){var c1:Point = new Point(x1, a.y);var d1:Point = new Point(x1, b.y);// 存在完整路线-- c,d点为零且纵向连通if ( _map.get(x1, a.y) == 0 && _map.get(x1, b.y) ==0 && _vTest(c1, d1) )v.append( new Line(Line.VERTICAL, c1, d1) );}// 扫描A 点右边的所有线for (var x2:Number = a.x; x2 < _map.width; x2++) {var c2:Point = new Point(x2, a.y);var d2:Point = new Point(x2, b.y);if ( _map.get(x2, a.y) == 0 && _map.get(x2, b.y) ==0 && _vTest(c2, d2) )v.append( new Line(Line.VERTICAL, c2, d2) );}// 从a, d 连线向b 扫描,扫描横线// 扫描A 点上面的所有线for (var y1:Number = a.y; y1 >= 0; y1--){var c3:Point = new Point(a.x, y1);var d3:Point = new Point(b.x, y1);if ( _map.get(a.x, y1) == 0 && _map.get(b.x, y1) ==0 && _hTest(c3, d3) )v.append( new Line(Line.HORIZONTAL, c3, d3) ); }// 扫描A 点下面的所有线for (var y2:Number = a.y; y2 < _map.height; y2++) {var c4:Point = new Point(a.x, y2);var d4:Point = new Point(b.x, y2);if ( _map.get(a.x, y2) == 0 && _map.get(b.x, y2) ==0 && _hTest(c4, d4) )v.append( new Line(Line.HORIZONTAL, c4, d4) );}return v;}/*** 对所有找到的符合线进行判断,看看AC 、DB 是否同样也可以消除* @param a* @param b* @return*/private function _twoCorner(a:Point, b:Point):MatchResult{_vector = _scanLine(a, b);if (_vector.isEmpty()) return null; //没有完整的空白线段,无解var itr:Iterator = _vector.getIterator();while (itr.hasNext()){var ln:Line = itr.next() as Line;switch (ln.direct){case Line.HORIZONTAL:if ( _vTest(a, ln.a) && _vTest(b, ln.b) ){_result.clear();return _result.fill(a.clone(), b.clone(),ln.a.clone(), ln.b.clone());}break;case Line.VERTICAL:if ( _hTest(a, ln.a) && _hTest(b, ln.b) ){_result.clear();return _result.fill(a.clone(), b.clone(),ln.a.clone(), ln.b.clone());}break;}}return null;}private function _findRestPointA(map:Array2 = null):Point {var m:Array2 = map || _map;if (m.width >= m.height){for (var col:Number = 0; col < m.width; col++){var max_y:Number = Math.min(col + 1, m.height);for (var y1:Number = 0; y1 < max_y; y1++){if (m.get(col, y1) != 0)return new Point(col, y1);}for (var x1:Number = 0; x1 < col; x1++){if (m.get(x1, max_y-1) != 0)return new Point(x1, max_y-1);}}}else{for (var row:Number = 0; row < m.height; row++){var max_x:Number = Math.min(row + 1, m.width);for (var x2:Number = 0; x2 < max_x; x2++){if (m.get(x2, row) != 0)return new Point(x2, row);}for (var y2:Number = 0; y2 < row; y2++){if (m.get(max_x-1, y2) != 0)return new Point(max_x-1, y2);}}}return null;}private function _findRestPointB(a:Point, ignore_b_arr:Array= null):Point{if (!a) return null;var tempMap:Array2 = ArrayUtil.cloneArray2(_map);tempMap.set(a.x, a.y, 0);if (ignore_b_arr && ignore_b_arr.length){for each (var bb:Point in ignore_b_arr)tempMap.set(bb.x, bb.y, 0);}var b:Point = _findRestPointA(tempMap);if (!b) return null;while ( _map.get(a.x, a.y) != _map.get(b.x, b.y) ){tempMap.set(b.x, b.y, 0);b = _findRestPointA(tempMap);if (!b) return null;}return b;}/********************** 公开方法**********************//*** 测试两点是否可以连通* @param a* @param b* @usage 判断两点的值相同并且满足连通条件* @return*/public function test(a:Point, b:Point):Boolean{_result = new MatchResult();if (_map.get(a.x, a.y) != _map.get(b.x, b.y))return false;if ( _hTest(a, b) || _vTest(a, b) || _oneCorner(a, b) ||_twoCorner(a, b) )return true;elsereturn false;}/*** 自动寻找一条可连通的路径* @return*/public function autoFindLine():MatchResult{var a:Point = _findRestPointA(); if (!a) return null;var b:Point = _findRestPointB(a); if (!b) return null;var ignoreA:Array = [];var ignoreB:Array = [];while ( !this.test(a, b) ){ignoreB.push(b);b = _findRestPointB(a, ignoreB);//基于A没有可以连通的点了, 换一个A试试if (!b){ignoreB = [];ignoreA.push(a);var tempMap:Array2 = ArrayUtil.cloneArray2(_map);tempMap.set(a.x, a.y, 0);if (ignoreA.length)for each (var p:Point in ignoreA)tempMap.set(p.x, p.y, 0);a = _findRestPointA(tempMap);b = _findRestPointB(a);}}//找不到可以连通的B点if (!b) return null;return _result.clone();}/*** 清除两点* @param a* @param b*/public function earse(a:Point, b:Point):void{_map.set(a.x, a.y, 0);_map.set(b.x, b.y, 0);_restBlock -= 2;}/*** 刷新*/public function refresh():void{var num:uint = this.count;if (num <= 0) return;_array = ArrayUtil.random( ArrayUtil.getWarppedMapArray(_map) );ArrayUtil.drawWrappedMap(_array, _map);}} }。

相关文档
最新文档